GCC Code Coverage Report

Directory: ./
File: sql/item_func.cc
Date: 2022-12-06 21:40:42
Exec Total Coverage
Lines: 4973 5351 92.9%
Branches: 4142 6279 66.0%
Line Branch Exec Source
1 /* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23 /**
24 @file
25
26 @brief
27 This file defines all numerical Items
28 */
29
30 #include "sql/item_func.h"
31
32 #include <algorithm>
33 #include <atomic>
34 #include <cfloat> // DBL_DIG
35 #include <cmath> // std::log2
36 #include <cstdio>
37 #include <cstring>
38 #include <ctime>
39 #include <initializer_list>
40 #include <iosfwd>
41 #include <limits> // std::numeric_limits
42 #include <memory>
43 #include <new>
44 #include <string>
45 #include <type_traits>
46 #include <unordered_map>
47 #include <utility>
48
49 #include "integer_digits.h"
50 #include "m_string.h"
51 #include "map_helpers.h"
52 #include "mutex_lock.h" // MUTEX_LOCK
53 #include "my_bit.h" // my_count_bits
54 #include "my_bitmap.h"
55 #include "my_byteorder.h"
56 #include "my_dbug.h"
57 #include "my_double2ulonglong.h"
58 #include "my_hostname.h"
59 #include "my_loglevel.h"
60 #include "my_psi_config.h"
61 #include "my_sqlcommand.h"
62 #include "my_sys.h"
63 #include "my_systime.h"
64 #include "my_thread.h"
65 #include "my_user.h" // parse_user
66 #include "mysql/components/services/bits/mysql_cond_bits.h"
67 #include "mysql/components/services/bits/mysql_mutex_bits.h"
68 #include "mysql/components/services/bits/psi_bits.h"
69 #include "mysql/components/services/bits/psi_mutex_bits.h"
70 #include "mysql/components/services/log_builtins.h"
71 #include "mysql/components/services/log_shared.h"
72 #include "mysql/mysql_lex_string.h"
73 #include "mysql/plugin_audit.h"
74 #include "mysql/psi/mysql_cond.h"
75 #include "mysql/psi/mysql_mutex.h"
76 #include "mysql/service_mysql_password_policy.h"
77 #include "mysql/service_thd_wait.h"
78 #include "mysql/status_var.h"
79 #include "prealloced_array.h"
80 #include "sql-common/json_dom.h" // Json_wrapper
81 #include "sql/auth/auth_acls.h"
82 #include "sql/auth/auth_common.h" // check_password_strength
83 #include "sql/auth/sql_security_ctx.h"
84 #include "sql/binlog.h" // mysql_bin_log
85 #include "sql/check_stack.h"
86 #include "sql/current_thd.h" // current_thd
87 #include "sql/dd/info_schema/table_stats.h" // dd::info_schema::Table_stati...
88 #include "sql/dd/info_schema/tablespace_stats.h" // dd::info_schema::Tablesp...
89 #include "sql/dd/object_id.h"
90 #include "sql/dd/properties.h" // dd::Properties
91 #include "sql/dd/types/abstract_table.h"
92 #include "sql/dd/types/column.h"
93 #include "sql/dd/types/index.h" // Index::enum_index_type
94 #include "sql/dd_sql_view.h" // push_view_warning_or_error
95 #include "sql/dd_table_share.h" // dd_get_old_field_type
96 #include "sql/debug_sync.h" // DEBUG_SYNC
97 #include "sql/derror.h" // ER_THD
98 #include "sql/error_handler.h" // Internal_error_handler
99 #include "sql/item.h" // Item_json
100 #include "sql/item_cmpfunc.h" // get_datetime_value
101 #include "sql/item_json_func.h" // get_json_wrapper
102 #include "sql/item_strfunc.h" // Item_func_concat_ws
103 #include "sql/item_subselect.h" // Item_subselect
104 #include "sql/key.h"
105 #include "sql/log_event.h" // server_version
106 #include "sql/mdl.h"
107 #include "sql/mysqld.h" // log_10 stage_user_sleep
108 #include "sql/parse_tree_helpers.h" // PT_item_list
109 #include "sql/parse_tree_node_base.h" // Parse_context
110 #include "sql/protocol.h"
111 #include "sql/psi_memory_key.h"
112 #include "sql/resourcegroups/resource_group.h"
113 #include "sql/resourcegroups/resource_group_basic_types.h"
114 #include "sql/resourcegroups/resource_group_mgr.h"
115 #include "sql/rpl_gtid.h"
116 #include "sql/rpl_mi.h" // Master_info
117 #include "sql/rpl_msr.h" // channel_map
118 #include "sql/rpl_rli.h" // Relay_log_info
119 #include "sql/sp.h" // sp_setup_routine
120 #include "sql/sp_head.h" // sp_name
121 #include "sql/sp_pcontext.h" // sp_variable
122 #include "sql/sql_array.h" // just to keep clang happy
123 #include "sql/sql_audit.h" // audit_global_variable
124 #include "sql/sql_base.h" // Internal_error_handler_holder
125 #include "sql/sql_bitmap.h"
126 #include "sql/sql_class.h" // THD
127 #include "sql/sql_cmd.h"
128 #include "sql/sql_derived.h" // Condition_pushdown
129 #include "sql/sql_error.h"
130 #include "sql/sql_exchange.h" // sql_exchange
131 #include "sql/sql_executor.h"
132 #include "sql/sql_lex.h"
133 #include "sql/sql_list.h"
134 #include "sql/sql_load.h" // Sql_cmd_load_table
135 #include "sql/sql_optimizer.h" // JOIN
136 #include "sql/sql_parse.h" // check_stack_overrun
137 #include "sql/sql_show.h" // append_identifier
138 #include "sql/sql_time.h" // TIME_from_longlong_packed
139 #include "sql/sql_zip_dict.h"
140 #include "sql/strfunc.h" // find_type
141 #include "sql/system_variables.h"
142 #include "sql/thd_raii.h"
143 #include "sql/val_int_compare.h" // Integer_value
144 #include "sql_string.h"
145 #include "template_utils.h" // pointer_cast
146 #include "thr_mutex.h"
147
148 using std::max;
149 using std::min;
150
151 180506 static void free_user_var(user_var_entry *entry) { entry->destroy(); }
152
153 static int get_var_with_binlog(THD *thd, enum_sql_command sql_command,
154 const Name_string &name,
155 user_var_entry **out_entry);
156
157 8233 bool check_reserved_words(const char *name) {
158 8233 if (!my_strcasecmp(system_charset_info, name, "GLOBAL") ||
159
6/6
✓ Branch 0 taken 8176 times.
✓ Branch 1 taken 57 times.
✓ Branch 2 taken 8134 times.
✓ Branch 3 taken 42 times.
✓ Branch 4 taken 111 times.
✓ Branch 5 taken 8122 times.
 16367 !my_strcasecmp(system_charset_info, name, "LOCAL") ||
160
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 8122 times.
 8134 !my_strcasecmp(system_charset_info, name, "SESSION"))
161 111 return true;
162 8122 return false;
163 }
164
165 57 void report_conversion_error(const CHARSET_INFO *to_cs, const char *from,
166 size_t from_length, const CHARSET_INFO *from_cs) {
167 char printable_buff[32];
168
1/2
✓ Branch 0 taken 57 times.
✗ Branch 1 not taken.
 57 convert_to_printable(printable_buff, sizeof(printable_buff), from,
169 from_length, from_cs, 6);
170 57 const char *from_name = from_cs->csname;
171 57 const char *to_name = to_cs->csname;
172
1/2
✓ Branch 0 taken 57 times.
✗ Branch 1 not taken.
 57 my_error(ER_CANNOT_CONVERT_STRING, MYF(0), printable_buff, from_name,
173 to_name);
174 57 }
175
176 /**
177 Simplify the string arguments to a function, if possible.
178
179 Currently used to substitute const values with character strings
180 in the desired character set. Only used during resolving.
181
182 @param thd thread handler
183 @param c Desired character set and collation
184 @param args Pointer to argument array
185 @param nargs Number of arguments to process
186
187 @returns false if success, true if error
188 */
189 977457 bool simplify_string_args(THD *thd, const DTCollation &c, Item **args,
190 uint nargs) {
191 // Only used during resolving
192
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 977457 times.
 977457 assert(!thd->lex->is_exec_started());
193
194
2/2
✓ Branch 0 taken 117870 times.
✓ Branch 1 taken 859587 times.
 977457 if (thd->lex->is_view_context_analysis()) return false;
195
196 uint i;
197 Item **arg;
198
2/2
✓ Branch 0 taken 859750 times.
✓ Branch 1 taken 859586 times.
 1719336 for (i = 0, arg = args; i < nargs; i++, arg++) {
199 size_t dummy_offset;
200 // Only convert const values.
201
3/4
✓ Branch 0 taken 859750 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30491 times.
✓ Branch 3 taken 829259 times.
 1677911 if (!(*arg)->const_item()) continue;
202
3/4
✓ Branch 0 taken 829259 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 818160 times.
✓ Branch 3 taken 11099 times.
 829259 if (!String::needs_conversion(1, (*arg)->collation.collation, c.collation,
203 &dummy_offset))
204 818160 continue;
205
206 11099 StringBuffer<STRING_BUFFER_USUAL_SIZE> original;
207 11099 StringBuffer<STRING_BUFFER_USUAL_SIZE> converted;
208
1/2
✓ Branch 0 taken 11099 times.
✗ Branch 1 not taken.
 11099 String *ostr = (*arg)->val_str(&original);
209
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 11098 times.
 11099 if (ostr == nullptr) {
210
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1 if (thd->is_error()) return true;
211
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 *arg = new (thd->mem_root) Item_null;
212
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (*arg == nullptr) return true;
213 1 continue;
214 }
215 uint conv_status;
216
1/2
✓ Branch 0 taken 11098 times.
✗ Branch 1 not taken.
 11098 converted.copy(ostr->ptr(), ostr->length(), ostr->charset(), c.collation,
217 &conv_status);
218
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 11097 times.
 11098 if (conv_status != 0) {
219
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 report_conversion_error(c.collation, ostr->ptr(), ostr->length(),
220 ostr->charset());
221 1 return true;
222 }
223 // If source is a binary string, the string may have to be validated:
224
3/6
✓ Branch 0 taken 11097 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 11097 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 11097 times.
 11097 if (c.collation != &my_charset_bin && ostr->charset() == &my_charset_bin &&
225 ✗ !converted.is_valid_string(c.collation)) {
226 ✗ report_conversion_error(c.collation, ostr->ptr(), ostr->length(),
227 ostr->charset());
228 ✗ return true;
229 }
230
231
1/2
✓ Branch 0 taken 11097 times.
✗ Branch 1 not taken.
 11097 char *ptr = thd->strmake(converted.ptr(), converted.length());
232
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11097 times.
 11097 if (ptr == nullptr) return true;
233 Item *conv = new (thd->mem_root)
234
2/4
✓ Branch 0 taken 11097 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11097 times.
✗ Branch 3 not taken.
 11097 Item_string(ptr, converted.length(), converted.charset(), c.derivation);
235
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11097 times.
 11097 if (conv == nullptr) return true;
236
237 11097 *arg = conv;
238
239
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11097 times.
 11097 assert(conv->fixed);
240
6/6
✓ Branch 0 taken 11097 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 11097 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 1 times.
 11101 }
241 859586 return false;
242 }
243
244 /**
245 Evaluate an argument string and return it in the desired character set.
246 Perform character set conversion if needed.
247 Perform character set validation (from a binary string) if needed.
248
249 @param to_cs The desired character set
250 @param arg Argument to evaluate as a string value
251 @param buffer String buffer where argument is evaluated, if necessary
252
253 @returns string pointer if success, NULL if error or NULL value
254 */
255
256 692287405 String *eval_string_arg(const CHARSET_INFO *to_cs, Item *arg, String *buffer) {
257
1/2
✓ Branch 0 taken 692287718 times.
✗ Branch 1 not taken.
 692287405 StringBuffer<STRING_BUFFER_USUAL_SIZE> local_string(nullptr, 0, to_cs);
258
259 size_t offset;
260 const bool convert =
261
1/2
✓ Branch 0 taken 692287659 times.
✗ Branch 1 not taken.
 692287718 String::needs_conversion(0, arg->collation.collation, to_cs, &offset);
262
3/4
✓ Branch 0 taken 4917765 times.
✓ Branch 1 taken 687369894 times.
✓ Branch 2 taken 692287559 times.
✗ Branch 3 not taken.
 692287659 String *res = arg->val_str(convert ? &local_string : buffer);
263
264 // Return immediately if argument is a NULL value, or there was an error
265
2/2
✓ Branch 0 taken 2973662 times.
✓ Branch 1 taken 689313897 times.
 692287559 if (res == nullptr) {
266 2973662 return nullptr;
267 }
268
2/2
✓ Branch 0 taken 4917445 times.
✓ Branch 1 taken 684396452 times.
 689313897 if (convert) {
269 /*
270 String must be converted from source character set. It has been built
271 in the "local_string" buffer and will be copied with conversion into the
272 caller provided buffer.
273 */
274 4917445 uint errors = 0;
275 4917445 buffer->length(0);
276
1/2
✓ Branch 0 taken 4917445 times.
✗ Branch 1 not taken.
 4917444 buffer->copy(res->ptr(), res->length(), res->charset(), to_cs, &errors);
277
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 4917440 times.
 4917445 if (errors) {
278
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 report_conversion_error(to_cs, res->ptr(), res->length(), res->charset());
279 5 return nullptr;
280 }
281 4917440 return buffer;
282 }
283 // If source is a binary string, the string may have to be validated:
284
6/6
✓ Branch 0 taken 684140082 times.
✓ Branch 1 taken 256370 times.
✓ Branch 2 taken 741226 times.
✓ Branch 3 taken 683398856 times.
✓ Branch 4 taken 30 times.
✓ Branch 5 taken 684396422 times.
 685137678 if (to_cs != &my_charset_bin && arg->collation.collation == &my_charset_bin &&
285
3/4
✓ Branch 0 taken 741226 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 741196 times.
 741226 !res->is_valid_string(to_cs)) {
286
1/2
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
 30 report_conversion_error(to_cs, res->ptr(), res->length(), res->charset());
287 30 return nullptr;
288 }
289 // Adjust target character set to the desired value
290 684396422 res->set_charset(to_cs);
291 684396390 return res;
292 692287527 }
293
294 /**
295 Evaluate a constant condition, represented by an Item tree
296
297 @param thd Thread handler
298 @param cond The constant condition to evaluate
299 @param[out] value Returned value, either true or false
300
301 @returns false if evaluation is successful, true otherwise
302 */
303
304 30477 bool eval_const_cond(THD *thd, Item *cond, bool *value) {
305 // Function may be used both during resolving and during optimization:
306
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30477 times.
 30477 assert(cond->may_evaluate_const(thd));
307 30477 *value = cond->val_bool();
308 30477 return thd->is_error();
309 }
310
311 /**
312 Test if the sum of arguments overflows the ulonglong range.
313 */
314 1667037 static inline bool test_if_sum_overflows_ull(ulonglong arg1, ulonglong arg2) {
315 1667037 return ULLONG_MAX - arg1 < arg2;
316 }
317
318 5253495 bool Item_func::set_arguments(mem_root_deque<Item *> *list, bool context_free) {
319 5253495 allowed_arg_cols = 1;
320
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5253496 times.
 5253495 if (alloc_args(*THR_MALLOC, list->size())) return true;
321 5253496 std::copy(list->begin(), list->end(), args);
322
2/2
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 5253469 times.
 5253498 if (!context_free) {
323
3/4
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 77 times.
✓ Branch 3 taken 29 times.
 106 for (const Item *arg : make_array(args, arg_count)) {
324 77 add_accum_properties(arg);
325 }
326 }
327 5253498 list->clear(); // Fields are used
328 5253498 return false;
329 }
330
331 5017246 Item_func::Item_func(const POS &pos, PT_item_list *opt_list)
332 5017246 : Item_result_field(pos), allowed_arg_cols(1) {
333
2/2
✓ Branch 0 taken 73975 times.
✓ Branch 1 taken 4943275 times.
 5017250 if (opt_list == nullptr) {
334 73975 args = m_embedded_arguments;
335 73975 arg_count = 0;
336 } else
337
1/2
✓ Branch 0 taken 4943277 times.
✗ Branch 1 not taken.
 4943275 set_arguments(&opt_list->value, true);
338 5017252 }
339
340 1554873 Item_func::Item_func(THD *thd, const Item_func *item)
341 : Item_result_field(thd, item),
342 1554880 null_on_null(item->null_on_null),
343 1554880 allowed_arg_cols(item->allowed_arg_cols),
344 1554880 used_tables_cache(item->used_tables_cache),
345 1554873 not_null_tables_cache(item->not_null_tables_cache) {
346
2/4
✓ Branch 0 taken 1554878 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1554878 times.
 1554880 if (alloc_args(thd->mem_root, item->arg_count)) return;
347
1/2
✓ Branch 0 taken 1554876 times.
✗ Branch 1 not taken.
 1554878 std::copy_n(item->args, arg_count, args);
348 }
349
350 36763659 bool Item_func::itemize(Parse_context *pc, Item **res) {
351
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 36763683 times.
 36763659 if (skip_itemize(res)) return false;
352
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36763709 times.
 36763683 if (Item_result_field::itemize(pc, res)) return true;
353 36763709 const bool no_named_params = !may_have_named_parameters();
354
2/2
✓ Branch 0 taken 86074573 times.
✓ Branch 1 taken 36763453 times.
 122838026 for (size_t i = 0; i < arg_count; i++) {
355 86074573 add_accum_properties(args[i]);
356
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 86074413 times.
 86074575 if (args[i]->itemize(pc, &args[i])) return true;
357
6/6
✓ Branch 0 taken 86043967 times.
✓ Branch 1 taken 30446 times.
✓ Branch 2 taken 43 times.
✓ Branch 3 taken 86043922 times.
✓ Branch 4 taken 43 times.
✓ Branch 5 taken 86074368 times.
 86074413 if (no_named_params && !args[i]->item_name.is_autogenerated()) {
358
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 41 times.
 43 my_error(functype() == FUNC_SP ? ER_WRONG_PARAMETERS_TO_STORED_FCT
359 : ER_WRONG_PARAMETERS_TO_NATIVE_FCT,
360 43 MYF(0), func_name());
361 43 return true;
362 }
363 }
364 36763453 return false;
365 }
366
367 /*
368 Resolve references to table column for a function and its argument
369
370 SYNOPSIS:
371 fix_fields()
372 thd Thread object
373
374 DESCRIPTION
375 Call fix_fields() for all arguments to the function. The main intention
376 is to allow all Item_field() objects to setup pointers to the table fields.
377
378 Sets as a side effect the following class variables:
379 maybe_null Set if any argument may return NULL
380 used_tables_cache Set to union of the tables used by arguments
381
382 str_value.charset If this is a string function, set this to the
383 character set for the first argument.
384 If any argument is binary, this is set to binary
385
386 If for any item any of the defaults are wrong, then this can
387 be fixed in the resolve_type() function that is called after this one or
388 by writing a specialized fix_fields() for the item.
389
390 RETURN VALUES
391 false ok
392 true Got error. Stored with my_error().
393 */
394
395 47007081 bool Item_func::fix_fields(THD *thd, Item **) {
396
4/6
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 47007078 times.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3 times.
 47007081 assert(fixed == 0 || basic_const_item());
397
398 Item **arg, **arg_end;
399 uchar buff[STACK_BUFF_ALLOC]; // Max argument in function
400
401 47007081 Condition_context CCT(thd->lex->current_query_block());
402
403
1/2
✓ Branch 0 taken 47007087 times.
✗ Branch 1 not taken.
 47007114 used_tables_cache = get_initial_pseudo_tables();
404 47007087 not_null_tables_cache = 0;
405
406 /*
407 Use stack limit of STACK_MIN_SIZE * 2 since
408 on some platforms a recursive call to fix_fields
409 requires more than STACK_MIN_SIZE bytes (e.g. for
410 MIPS, it takes about 22kB to make one recursive
411 call to Item_func::fix_fields())
412 */
413
3/4
✓ Branch 0 taken 47007137 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 47007136 times.
 47007087 if (check_stack_overrun(thd, STACK_MIN_SIZE * 2, buff))
414 1 return true; // Fatal error if flag is set!
415
2/2
✓ Branch 0 taken 45479904 times.
✓ Branch 1 taken 1527232 times.
 47007136 if (arg_count) { // Print purify happy
416
2/2
✓ Branch 0 taken 109576946 times.
✓ Branch 1 taken 45475788 times.
 155052734 for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) {
417
3/4
✓ Branch 0 taken 109576911 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4081 times.
✓ Branch 3 taken 109572830 times.
 109576946 if (fix_func_arg(thd, arg)) return true;
418 }
419 }
420
421
8/10
✓ Branch 0 taken 47003039 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 47002611 times.
✓ Branch 3 taken 428 times.
✓ Branch 4 taken 47002618 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 14 times.
✓ Branch 7 taken 47002604 times.
✓ Branch 8 taken 437 times.
✓ Branch 9 taken 47002609 times.
 47003020 if (resolve_type(thd) || thd->is_error()) // Some impls still not error-safe
422 437 return true;
423 47002609 fixed = true;
424 47002609 return false;
425 47007128 }
426
427 109579694 bool Item_func::fix_func_arg(THD *thd, Item **arg) {
428
6/6
✓ Branch 0 taken 55880294 times.
✓ Branch 1 taken 53699400 times.
✓ Branch 2 taken 4065 times.
✓ Branch 3 taken 55876175 times.
✓ Branch 4 taken 4065 times.
✓ Branch 5 taken 109575575 times.
 109579694 if ((!(*arg)->fixed && (*arg)->fix_fields(thd, arg)))
429 4065 return true; /* purecov: inspected */
430 109575575 Item *item = *arg;
431
432
2/2
✓ Branch 0 taken 96061486 times.
✓ Branch 1 taken 13514089 times.
 109575575 if (allowed_arg_cols) {
433
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 96061475 times.
 96061486 if (item->check_cols(allowed_arg_cols)) return true;
434 } else {
435 /* we have to fetch allowed_arg_cols from first argument */
436
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13514089 times.
 13514089 assert(arg == args); // it is first argument
437 13514089 allowed_arg_cols = item->cols();
438
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13514140 times.
 13514140 assert(allowed_arg_cols); // Can't be 0 any more
439 }
440
441
4/4
✓ Branch 0 taken 88331246 times.
✓ Branch 1 taken 21244347 times.
✓ Branch 2 taken 17649064 times.
✓ Branch 3 taken 70682245 times.
 109575615 set_nullable(is_nullable() || item->is_nullable());
442 109575611 used_tables_cache |= item->used_tables();
443
2/2
✓ Branch 0 taken 79815984 times.
✓ Branch 1 taken 29759595 times.
 109575579 if (null_on_null) not_null_tables_cache |= item->not_null_tables();
444 109575581 add_accum_properties(item);
445
446 109575599 return false;
447 }
448
449 27343506 void Item_func::fix_after_pullout(Query_block *parent_query_block,
450 Query_block *removed_query_block) {
451
2/2
✓ Branch 0 taken 447124 times.
✓ Branch 1 taken 26896382 times.
 27343506 if (const_item()) {
452 /*
453 Pulling out a const item changes nothing to it. Moreover, some items may
454 have decided that they're const by some other logic than the generic
455 one below, and we must preserve that decision.
456 */
457 447124 return;
458 }
459
460 Item **arg, **arg_end;
461
462 26896382 used_tables_cache = get_initial_pseudo_tables();
463 26896383 not_null_tables_cache = 0;
464
465
2/2
✓ Branch 0 taken 26891788 times.
✓ Branch 1 taken 4595 times.
 26896383 if (arg_count) {
466
2/2
✓ Branch 0 taken 72895954 times.
✓ Branch 1 taken 26891780 times.
 99787734 for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) {
467 72895954 Item *const item = *arg;
468 72895954 item->fix_after_pullout(parent_query_block, removed_query_block);
469 72895949 used_tables_cache |= item->used_tables();
470
2/2
✓ Branch 0 taken 26770148 times.
✓ Branch 1 taken 46125801 times.
 72895949 if (null_on_null) not_null_tables_cache |= item->not_null_tables();
471 }
472 }
473 }
474
475 /**
476 Default implementation for all functions:
477 Propagate base_item's type into all arguments.
478
479 The functions that have context-aware parameter type detection must
480 implement Item::default_data_type() and Item::resolve_type_inner().
481
482 If an SQL function or operator F embeds another SQL function or
483 operator G: F::fix_fields() runs and calls G::fix_fields() which calls
484 G::resolve_type(); assuming that G is outer-context dependent and has only
485 dynamic parameters as arguments, G misses type information and thus does a
486 no-op resolve_type(); then F::fix_fields() continues and calls
487 F::resolve_type() which sees that G::data_type() == MYSQL_TYPE_INVALID;
488 F thus calls G::propagate_type() to send it the necessary type
489 information (i.e. provide the outer context); this then assigns the type
490 to dynamic parameters of G and finishes the job of G::resolve_type() by
491 calling G::resolve_type_inner().
492 */
493 62 bool Item_func::propagate_type(THD *thd, const Type_properties &type) {
494
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
 62 assert(data_type() == MYSQL_TYPE_INVALID);
495
2/2
✓ Branch 0 taken 139 times.
✓ Branch 1 taken 62 times.
 201 for (uint i = 0; i < arg_count; i++) {
496
2/2
✓ Branch 0 taken 124 times.
✓ Branch 1 taken 15 times.
 139 if (args[i]->data_type() == MYSQL_TYPE_INVALID)
497
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 124 times.
 124 if (args[i]->propagate_type(thd, type)) return true;
498 }
499
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 61 times.
 62 if (resolve_type_inner(thd)) return true;
500
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
 61 assert(data_type() != MYSQL_TYPE_INVALID);
501
502 61 return false;
503 }
504
505 /**
506 For arguments of this Item_func ("args" array), in range
507 [start, start+step, start+2*step,...,end[ : if they're a PS
508 parameter with invalid (not known) type, give them default type "def".
509 @param thd thread handler
510 @param start range's start (included)
511 @param end range's end (excluded)
512 @param step range's step
513 @param def default type
514
515 @returns false if success, true if error
516 */
517 27165601 bool Item_func::param_type_is_default(THD *thd, uint start, uint end, uint step,
518 enum_field_types def) {
519
2/2
✓ Branch 0 taken 38788166 times.
✓ Branch 1 taken 21683098 times.
 60471264 for (uint i = start; i < end; i += step) {
520
2/2
✓ Branch 0 taken 5482500 times.
✓ Branch 1 taken 33305666 times.
 38788166 if (i >= arg_count) break;
521
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 33305663 times.
 33305666 if (args[i]->propagate_type(thd, def)) return true;
522 }
523 27165598 return false;
524 }
525
526 /**
527 For arguments of this Item_func ("args" array), in range [start,end[ :
528 sends error if they're a dynamic parameter.
529 @param start range's start (included)
530 @param end range's end (excluded)
531 @returns true if error.
532 */
533 290714 bool Item_func::param_type_is_rejected(uint start, uint end) {
534
2/2
✓ Branch 0 taken 290728 times.
✓ Branch 1 taken 24 times.
 290752 for (uint i = start; i < end; i++) {
535
2/2
✓ Branch 0 taken 290687 times.
✓ Branch 1 taken 41 times.
 290728 if (i >= arg_count) break;
536
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 38 times.
 41 if (args[i]->data_type() == MYSQL_TYPE_INVALID) {
537 3 my_error(ER_INVALID_PARAMETER_USE, MYF(0), "?");
538 3 return true;
539 }
540 }
541 290711 return false;
542 }
543
544 /**
545 For arguments of this Item_func ("args" array), all of them: find an
546 argument that is not a dynamic parameter; if found, all dynamic parameters
547 without a valid type get the type of this; if not found, they get type "def".
548
549 @param thd thread handler
550 @param arg_count number of arguments to check
551 @param args array of arguments, size 'arg_count'
552 @param def default type
553
554 @returns false if success, true if error
555 */
556 26229053 inline bool param_type_uses_non_param_inner(THD *thd, uint arg_count,
557 Item **args, enum_field_types def) {
558 // Use first non-parameter type as base item
559 // @todo If there are multiple non-parameter items, we could use a
560 // consolidated type instead of the first one (consider CASE, COALESCE,
561 // BETWEEN).
562 26229053 uint col_cnt = args[0]->cols();
563
2/2
✓ Branch 0 taken 475 times.
✓ Branch 1 taken 26228583 times.
 26229058 if (col_cnt > 1) {
564 /*
565 Row or subquery object: set parameter type recursively for the ith
566 Item in each argument row.
567 */
568
1/2
✓ Branch 0 taken 466 times.
✗ Branch 1 not taken.
 475 Item **arguments = new (*THR_MALLOC) Item *[arg_count];
569
2/2
✓ Branch 0 taken 1058 times.
✓ Branch 1 taken 458 times.
 1516 for (uint i = 0; i < col_cnt; i++) {
570
2/2
✓ Branch 0 taken 2848 times.
✓ Branch 1 taken 1050 times.
 3898 for (uint j = 0; j < arg_count; j++) {
571
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2840 times.
 2848 if (args[j]->cols() != col_cnt) // Column count not checked yet
572 8 return false;
573
2/2
✓ Branch 0 taken 2770 times.
✓ Branch 1 taken 70 times.
 2840 if (args[j]->type() == Item::ROW_ITEM)
574 2770 arguments[j] = down_cast<Item_row *>(args[j])->element_index(i);
575
1/2
✓ Branch 0 taken 70 times.
✗ Branch 1 not taken.
 70 else if (args[j]->type() == Item::SUBSELECT_ITEM)
576 70 arguments[j] = (*down_cast<Item_subselect *>(args[j])
577 70 ->unit->get_unit_column_types())[i];
578 }
579
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1050 times.
 1050 if (param_type_uses_non_param_inner(thd, arg_count, arguments, def))
580 ✗ return true;
581 }
582 // Resolving for row done, set data type to MYSQL_TYPE_NULL as final action.
583
2/2
✓ Branch 0 taken 1235 times.
✓ Branch 1 taken 458 times.
 1693 for (uint j = 0; j < arg_count; j++)
584 1235 args[j]->set_data_type(MYSQL_TYPE_NULL);
585 458 return false;
586 }
587 26228583 Item *base_item = nullptr;
588
2/2
✓ Branch 0 taken 26229387 times.
✓ Branch 1 taken 138 times.
 26229525 for (uint i = 0; i < arg_count; i++) {
589
2/2
✓ Branch 0 taken 26228445 times.
✓ Branch 1 taken 942 times.
 26229387 if (args[i]->data_type() != MYSQL_TYPE_INVALID) {
590 26228445 base_item = args[i];
591 26228445 break;
592 }
593 }
594
2/2
✓ Branch 0 taken 142 times.
✓ Branch 1 taken 26228441 times.
 26228583 if (base_item == nullptr) {
595
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 142 times.
 142 if (args[0]->propagate_type(thd, def)) return true;
596 142 base_item = args[0];
597 }
598
2/2
✓ Branch 0 taken 54515077 times.
✓ Branch 1 taken 26228598 times.
 80743675 for (uint i = 0; i < arg_count; i++) {
599
2/2
✓ Branch 0 taken 54512186 times.
✓ Branch 1 taken 2900 times.
 54515077 if (args[i]->data_type() != MYSQL_TYPE_INVALID) continue;
600
2/4
✓ Branch 0 taken 2906 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2906 times.
 2900 if (args[i]->propagate_type(thd, Type_properties(*base_item))) return true;
601 }
602 26228598 return false;
603 }
604
605 31461507 bool Item_func::param_type_uses_non_param(THD *thd, enum_field_types def) {
606
2/2
✓ Branch 0 taken 5233508 times.
✓ Branch 1 taken 26227999 times.
 31461507 if (arg_count == 0) return false;
607 26227999 return param_type_uses_non_param_inner(thd, arg_count, args, def);
608 }
609
610 50268042 bool Item_func::walk(Item_processor processor, enum_walk walk,
611 uchar *argument) {
612
8/8
✓ Branch 0 taken 18295658 times.
✓ Branch 1 taken 31973249 times.
✓ Branch 2 taken 13388729 times.
✓ Branch 3 taken 4906929 times.
✓ Branch 4 taken 41 times.
✓ Branch 5 taken 18295500 times.
✓ Branch 6 taken 41 times.
✓ Branch 7 taken 50268749 times.
 50268042 if ((walk & enum_walk::PREFIX) && (this->*processor)(argument)) return true;
613
614 Item **arg, **arg_end;
615
2/2
✓ Branch 0 taken 121685742 times.
✓ Branch 1 taken 50262766 times.
 171948508 for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) {
616
2/2
✓ Branch 0 taken 6216 times.
✓ Branch 1 taken 121679759 times.
 121685742 if ((*arg)->walk(processor, walk, argument)) return true;
617 }
618
6/6
✓ Branch 0 taken 32518430 times.
✓ Branch 1 taken 17744645 times.
✓ Branch 2 taken 27823569 times.
✓ Branch 3 taken 4694861 times.
✓ Branch 4 taken 1040 times.
✓ Branch 5 taken 32517366 times.
 50262766 return (walk & enum_walk::POSTFIX) && (this->*processor)(argument);
619 }
620
621 ✗ void Item_func::traverse_cond(Cond_traverser traverser, void *argument,
622 traverse_order order) {
623 ✗ if (arg_count) {
624 Item **arg, **arg_end;
625
626 ✗ switch (order) {
627 ✗ case (PREFIX):
628 ✗ (*traverser)(this, argument);
629 ✗ for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) {
630 ✗ (*arg)->traverse_cond(traverser, argument, order);
631 }
632 ✗ break;
633 ✗ case (POSTFIX):
634 ✗ for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) {
635 ✗ (*arg)->traverse_cond(traverser, argument, order);
636 }
637 ✗ (*traverser)(this, argument);
638 }
639 } else
640 ✗ (*traverser)(this, argument);
641 }
642
643 /**
644 Transform an Item_func object with a transformer callback function.
645
646 The function recursively applies the transform method to each
647 argument of the Item_func node.
648 If the call of the method for an argument item returns a new item
649 the old item is substituted for a new one.
650 After this the transformer is applied to the root node
651 of the Item_func object.
652 */
653
654 968591 Item *Item_func::transform(Item_transformer transformer, uchar *argument) {
655
2/2
✓ Branch 0 taken 118623 times.
✓ Branch 1 taken 849968 times.
 968591 if (arg_count) {
656 Item **arg, **arg_end;
657
2/2
✓ Branch 0 taken 237629 times.
✓ Branch 1 taken 118623 times.
 356252 for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) {
658 237629 *arg = (*arg)->transform(transformer, argument);
659
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 237629 times.
 237629 if (*arg == nullptr) return nullptr; /* purecov: inspected */
660 }
661 }
662
2/2
✓ Branch 0 taken 126482 times.
✓ Branch 1 taken 842109 times.
 968591 return (this->*transformer)(argument);
663 }
664
665 /**
666 Compile Item_func object with a processor and a transformer
667 callback functions.
668
669 First the function applies the analyzer to the root node of
670 the Item_func object. Then if the analyzer succeeeds (returns true)
671 the function recursively applies the compile method to each argument
672 of the Item_func node.
673 If the call of the method for an argument item returns a new item
674 the old item is substituted for a new one.
675 After this the transformer is applied to the root node
676 of the Item_func object.
677 */
678
679 9376729 Item *Item_func::compile(Item_analyzer analyzer, uchar **arg_p,
680 Item_transformer transformer, uchar *arg_t) {
681
4/4
✓ Branch 0 taken 6495600 times.
✓ Branch 1 taken 2881129 times.
✓ Branch 2 taken 9282 times.
✓ Branch 3 taken 9367463 times.
 9376729 if (!(this->*analyzer)(arg_p)) return this;
682
2/2
✓ Branch 0 taken 9207678 times.
✓ Branch 1 taken 159785 times.
 9367463 if (arg_count) {
683 Item **arg, **arg_end;
684
2/2
✓ Branch 0 taken 19928500 times.
✓ Branch 1 taken 9207694 times.
 29136194 for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) {
685 /*
686 The same parameter value of arg_p must be passed
687 to analyze any argument of the condition formula.
688 */
689 19928500 uchar *arg_v = *arg_p;
690
1/2
✓ Branch 0 taken 19928498 times.
✗ Branch 1 not taken.
 19928500 Item *new_item = (*arg)->compile(analyzer, &arg_v, transformer, arg_t);
691
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 19928496 times.
 19928498 if (new_item == nullptr) return nullptr;
692
4/6
✓ Branch 0 taken 148155 times.
✓ Branch 1 taken 19780341 times.
✓ Branch 2 taken 148155 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 148175 times.
✗ Branch 5 not taken.
 19928496 if (*arg != new_item) current_thd->change_item_tree(arg, new_item);
693 }
694 }
695
2/2
✓ Branch 0 taken 5789621 times.
✓ Branch 1 taken 3577858 times.
 9367479 return (this->*transformer)(arg_t);
696 }
697
698 /**
699 See comments in Item_cmp_func::split_sum_func()
700 */
701
702 402328 void Item_func::split_sum_func(THD *thd, Ref_item_array ref_item_array,
703 mem_root_deque<Item *> *fields) {
704 Item **arg, **arg_end;
705
2/2
✓ Branch 0 taken 746387 times.
✓ Branch 1 taken 402328 times.
 1148715 for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++)
706 746387 (*arg)->split_sum_func2(thd, ref_item_array, fields, arg, true);
707 402328 }
708
709 57235471 void Item_func::update_used_tables() {
710 57235471 used_tables_cache = get_initial_pseudo_tables();
711 57235747 not_null_tables_cache = 0;
712
713
2/2
✓ Branch 0 taken 120936409 times.
✓ Branch 1 taken 57235702 times.
 178172111 for (uint i = 0; i < arg_count; i++) {
714 120936409 args[i]->update_used_tables();
715 120936187 used_tables_cache |= args[i]->used_tables();
716
2/2
✓ Branch 0 taken 112752972 times.
✓ Branch 1 taken 8183366 times.
 120936338 if (null_on_null) not_null_tables_cache |= args[i]->not_null_tables();
717 120936454 add_accum_properties(args[i]);
718 }
719 57235702 }
720
721 1693985 void Item_func::print(const THD *thd, String *str,
722 enum_query_type query_type) const {
723
1/2
✓ Branch 0 taken 1693986 times.
✗ Branch 1 not taken.
 1693985 str->append(func_name());
724 1693986 str->append('(');
725 1693985 print_args(thd, str, 0, query_type);
726 1693985 str->append(')');
727 1693985 }
728
729 1755967 void Item_func::print_args(const THD *thd, String *str, uint from,
730 enum_query_type query_type) const {
731
2/2
✓ Branch 0 taken 3893772 times.
✓ Branch 1 taken 1755967 times.
 5649739 for (uint i = from; i < arg_count; i++) {
732
2/2
✓ Branch 0 taken 2215068 times.
✓ Branch 1 taken 1678704 times.
 3893772 if (i != from) str->append(',');
733 3893772 args[i]->print(thd, str, query_type);
734 }
735 1755967 }
736
737 1183285 void Item_func::print_op(const THD *thd, String *str,
738 enum_query_type query_type) const {
739 1183285 str->append('(');
740
2/2
✓ Branch 0 taken 1183285 times.
✓ Branch 1 taken 1183286 times.
 2366571 for (uint i = 0; i < arg_count - 1; i++) {
741 1183285 args[i]->print(thd, str, query_type);
742 1183286 str->append(' ');
743
1/2
✓ Branch 0 taken 1183286 times.
✗ Branch 1 not taken.
 1183286 str->append(func_name());
744 1183286 str->append(' ');
745 }
746 1183286 args[arg_count - 1]->print(thd, str, query_type);
747 1183286 str->append(')');
748 1183286 }
749
750 /// @note Please keep in sync with Item_sum::eq().
751 501750 bool Item_func::eq(const Item *item, bool binary_cmp) const {
752 /* Assume we don't have rtti */
753
2/2
✓ Branch 0 taken 71271 times.
✓ Branch 1 taken 430479 times.
 501750 if (this == item) return true;
754
2/2
✓ Branch 0 taken 178271 times.
✓ Branch 1 taken 252209 times.
 430479 if (item->type() != FUNC_ITEM) return false;
755 252209 const Item_func *item_func = down_cast<const Item_func *>(item);
756 Item_func::Functype func_type;
757 252209 if ((func_type = functype()) != item_func->functype() ||
758
4/4
✓ Branch 0 taken 155539 times.
✓ Branch 1 taken 320 times.
✓ Branch 2 taken 154509 times.
✓ Branch 3 taken 1030 times.
 155859 arg_count != item_func->arg_count ||
759 154509 (func_type != Item_func::FUNC_SP &&
760
8/8
✓ Branch 0 taken 155859 times.
✓ Branch 1 taken 96350 times.
✓ Branch 2 taken 151691 times.
✓ Branch 3 taken 2818 times.
✓ Branch 4 taken 1030 times.
✓ Branch 5 taken 151691 times.
✓ Branch 6 taken 100006 times.
✓ Branch 7 taken 152203 times.
 409098 strcmp(func_name(), item_func->func_name()) != 0) ||
761 1030 (func_type == Item_func::FUNC_SP &&
762
2/2
✓ Branch 0 taken 518 times.
✓ Branch 1 taken 512 times.
 1030 my_strcasecmp(system_charset_info, func_name(), item_func->func_name())))
763 100006 return false;
764 152203 return AllItemsAreEqual(args, item_func->args, arg_count, binary_cmp);
765 }
766
767 68275 Field *Item_func::tmp_table_field(TABLE *table) {
768 68275 Field *field = nullptr;
769
770
3/5
✓ Branch 0 taken 6370 times.
✓ Branch 1 taken 125 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 61780 times.
✗ Branch 4 not taken.
 68275 switch (result_type()) {
771 6370 case INT_RESULT:
772
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6369 times.
 6370 if (this->data_type() == MYSQL_TYPE_YEAR)
773
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 field = new (*THR_MALLOC) Field_year(is_nullable(), item_name.ptr());
774
2/2
✓ Branch 0 taken 2164 times.
✓ Branch 1 taken 4205 times.
 6369 else if (max_length > MY_INT32_NUM_DECIMAL_DIGITS)
775
1/2
✓ Branch 0 taken 2164 times.
✗ Branch 1 not taken.
 6492 field = new (*THR_MALLOC) Field_longlong(
776
1/2
✓ Branch 0 taken 2164 times.
✗ Branch 1 not taken.
 6492 max_length, is_nullable(), item_name.ptr(), unsigned_flag);
777 else
778
1/2
✓ Branch 0 taken 4205 times.
✗ Branch 1 not taken.
 16820 field = new (*THR_MALLOC) Field_long(max_length, is_nullable(),
779
1/2
✓ Branch 0 taken 4205 times.
✗ Branch 1 not taken.
 12615 item_name.ptr(), unsigned_flag);
780 6370 break;
781 125 case REAL_RESULT:
782
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 122 times.
 125 if (this->data_type() == MYSQL_TYPE_FLOAT) {
783
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 9 field = new (*THR_MALLOC)
784 3 Field_float(max_char_length(), is_nullable(), item_name.ptr(),
785
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 6 decimals, unsigned_flag);
786 } else {
787
1/2
✓ Branch 0 taken 122 times.
✗ Branch 1 not taken.
 366 field = new (*THR_MALLOC)
788 122 Field_double(max_char_length(), is_nullable(), item_name.ptr(),
789
1/2
✓ Branch 0 taken 122 times.
✗ Branch 1 not taken.
 244 decimals, unsigned_flag);
790 }
791 125 break;
792 ✗ case STRING_RESULT:
793 ✗ return make_string_field(table);
794 break;
795 61780 case DECIMAL_RESULT:
796 61780 field = Field_new_decimal::create_from_item(this);
797 61780 break;
798 ✗ case ROW_RESULT:
799 default:
800 // This case should never be chosen
801 ✗ assert(0);
802 field = nullptr;
803 break;
804 }
805
1/2
✓ Branch 0 taken 68275 times.
✗ Branch 1 not taken.
 68275 if (field) field->init(table);
806 68275 return field;
807 }
808
809 1335759 my_decimal *Item_func::val_decimal(my_decimal *decimal_value) {
810
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1335759 times.
 1335759 assert(fixed);
811 1335759 longlong nr = val_int();
812
2/2
✓ Branch 0 taken 599270 times.
✓ Branch 1 taken 736489 times.
 1335759 if (null_value) return nullptr; /* purecov: inspected */
813 736489 int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
814 736489 return decimal_value;
815 }
816
817 518601 String *Item_real_func::val_str(String *str) {
818
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 518601 times.
 518601 assert(fixed == 1);
819 518601 double nr = val_real();
820
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 518750 times.
 518758 if (null_value) return nullptr; /* purecov: inspected */
821 518750 str->set_real(nr, decimals, collation.collation);
822 519232 return str;
823 }
824
825 10 my_decimal *Item_real_func::val_decimal(my_decimal *decimal_value) {
826
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 assert(fixed);
827 10 double nr = val_real();
828
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
 10 if (null_value) return nullptr; /* purecov: inspected */
829 5 double2my_decimal(E_DEC_FATAL_ERROR, nr, decimal_value);
830 5 return decimal_value;
831 }
832
833 96 void Item_func::fix_num_length_and_dec() {
834 96 uint fl_length = 0;
835 96 decimals = 0;
836
2/2
✓ Branch 0 taken 112 times.
✓ Branch 1 taken 96 times.
 208 for (uint i = 0; i < arg_count; i++) {
837 112 decimals = max(decimals, args[i]->decimals);
838 112 fl_length = max(fl_length, args[i]->max_length);
839 }
840 96 max_length = float_length(decimals);
841
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 94 times.
 96 if (fl_length > max_length) {
842 2 decimals = DECIMAL_NOT_SPECIFIED;
843 2 max_length = float_length(DECIMAL_NOT_SPECIFIED);
844 }
845 96 }
846
847 4220665 void Item_func_numhybrid::fix_num_length_and_dec() {}
848
849 14795 void Item_func::signal_divide_by_null() {
850 14795 THD *thd = current_thd;
851
2/2
✓ Branch 0 taken 10469 times.
✓ Branch 1 taken 4326 times.
 14795 if (thd->variables.sql_mode & MODE_ERROR_FOR_DIVISION_BY_ZERO)
852 10469 push_warning(thd, Sql_condition::SL_WARNING, ER_DIVISION_BY_ZERO,
853 ER_THD(thd, ER_DIVISION_BY_ZERO));
854 14795 null_value = true;
855 14795 }
856
857 60 void Item_func::signal_invalid_argument_for_log() {
858 60 THD *thd = current_thd;
859 60 push_warning(thd, Sql_condition::SL_WARNING,
860 ER_INVALID_ARGUMENT_FOR_LOGARITHM,
861 ER_THD(thd, ER_INVALID_ARGUMENT_FOR_LOGARITHM));
862 60 null_value = true;
863 60 }
864
865 62861 Item *Item_func::get_tmp_table_item(THD *thd) {
866
1/2
✓ Branch 0 taken 62861 times.
✗ Branch 1 not taken.
 62861 DBUG_TRACE;
867
868 /*
869 For items with aggregate functions, return the copy
870 of the function.
871 For constant items, return the same object, as fields
872 are not created in temp tables for them.
873 For items with windowing functions, return the same
874 object (temp table fields are not created for windowing
875 functions if they are not evaluated at this stage).
876 */
877
6/6
✓ Branch 0 taken 62603 times.
✓ Branch 1 taken 258 times.
✓ Branch 2 taken 62540 times.
✓ Branch 3 taken 63 times.
✓ Branch 4 taken 61214 times.
✓ Branch 5 taken 1647 times.
 125401 if (!has_aggregation() && !has_wf() &&
878
3/4
✓ Branch 0 taken 62540 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1326 times.
✓ Branch 3 taken 61214 times.
 62540 !(const_for_execution() &&
879
2/4
✓ Branch 0 taken 1326 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1326 times.
 1326 evaluate_during_optimization(this, thd->lex->current_query_block()))) {
880
2/4
✓ Branch 0 taken 61214 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 61214 times.
✗ Branch 3 not taken.
 61214 Item *result = new Item_field(result_field);
881 61214 return result;
882 }
883
1/2
✓ Branch 0 taken 1647 times.
✗ Branch 1 not taken.
 1647 Item *result = copy_or_same(thd);
884 1647 return result;
885 62861 }
886
887 62827831 const Item_field *Item_func::contributes_to_filter(
888 table_map read_tables, table_map filter_for_table,
889 const MY_BITMAP *fields_to_ignore) const {
890
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 62827831 times.
 62827831 assert((read_tables & filter_for_table) == 0);
891 /*
892 Multiple equality (Item_equal) should not call this function
893 because it would reject valid comparisons.
894 */
895
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 62827900 times.
 62827831 assert(functype() != MULT_EQUAL_FUNC);
896
897 /*
898 To contribute to filtering effect, the condition must refer to
899 exactly one unread table: the table filtering is currently
900 calculated for.
901 */
902
2/2
✓ Branch 0 taken 52806879 times.
✓ Branch 1 taken 10021023 times.
 62827900 if ((used_tables() & ~read_tables) != filter_for_table) return nullptr;
903
904 /*
905 Whether or not this Item_func has an operand that is a field in
906 'filter_for_table' that is not in 'fields_to_ignore'.
907 */
908 10021023 Item_field *usable_field = nullptr;
909
910 /*
911 Whether or not this Item_func has an operand that can be used as
912 available value. arg_count==1 for Items with implicit values like
913 "field IS NULL".
914 */
915 10021023 bool found_comparable = (arg_count == 1);
916
917
2/2
✓ Branch 0 taken 20004088 times.
✓ Branch 1 taken 10020673 times.
 30024761 for (uint i = 0; i < arg_count; i++) {
918 20004088 const Item::Type arg_type = args[i]->real_item()->type();
919
920
2/2
✓ Branch 0 taken 435 times.
✓ Branch 1 taken 20003661 times.
 20004096 if (arg_type == Item::SUBSELECT_ITEM) {
921
2/2
✓ Branch 0 taken 86 times.
✓ Branch 1 taken 349 times.
 435 if (args[i]->const_for_execution()) {
922 // Constant subquery, i.e., not a dependent subquery.
923 86 found_comparable = true;
924 86 continue;
925 }
926
927 /*
928 This is either "fld OP <dependent_subquery>" or "fld BETWEEN X
929 and Y" where either X or Y is a dependent subquery. Filtering
930 effect should not be calculated for this item because the cost
931 of evaluating the dependent subquery is currently not
932 calculated and its accompanying filtering effect is too
933 uncertain. See WL#7384.
934 */
935 349 return nullptr;
936 } // ... if subquery.
937
938 20003661 const table_map used_tabs = args[i]->used_tables();
939
940
4/4
✓ Branch 0 taken 4119171 times.
✓ Branch 1 taken 15884481 times.
✓ Branch 2 taken 4025888 times.
✓ Branch 3 taken 93283 times.
 20003652 if (arg_type == Item::FIELD_ITEM && (used_tabs == filter_for_table)) {
941 /*
942 The qualifying table of args[i] is filter_for_table. args[i]
943 may be a field or a reference to a field, e.g. through a
944 view.
945 */
946 4025888 Item_field *fld = static_cast<Item_field *>(args[i]->real_item());
947
948 /*
949 Use args[i] as value if
950 1) this field shall be ignored, or
951 2) a usable field has already been found (meaning that
952 this is "filter_for_table.colX OP filter_for_table.colY").
953 */
954
6/6
✓ Branch 0 taken 4003273 times.
✓ Branch 1 taken 22615 times.
✓ Branch 2 taken 284 times.
✓ Branch 3 taken 4002989 times.
✓ Branch 4 taken 22899 times.
✓ Branch 5 taken 4002989 times.
 4025888 if (bitmap_is_set(fields_to_ignore, fld->field->field_index()) || // 1)
955 usable_field) // 2)
956 {
957 22899 found_comparable = true;
958 22899 continue;
959 }
960
961 /*
962 This field shall contribute to filtering effect if a
963 value is found for it
964 */
965 4002989 usable_field = fld;
966 4002989 } // if field.
967 else {
968 /*
969 It's not a subquery. May be a function, a constant, an outer
970 reference, a field of another table...
971
972 Already checked that this predicate does not refer to tables
973 later in the join sequence. Verify it:
974 */
975
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15977764 times.
 15977764 assert(!(used_tabs & (~read_tables & ~filter_for_table)));
976 15977764 found_comparable = true;
977 }
978 }
979
1/2
✓ Branch 0 taken 10020729 times.
✗ Branch 1 not taken.
 10020673 return (found_comparable ? usable_field : nullptr);
980 }
981
982 118074 bool Item_func::is_valid_for_pushdown(uchar *arg) {
983 Condition_pushdown::Derived_table_info *dti =
984 118074 pointer_cast<Condition_pushdown::Derived_table_info *>(arg);
985 // We cannot push conditions that are not deterministic to a
986 // derived table having set operations.
987
4/4
✓ Branch 0 taken 170 times.
✓ Branch 1 taken 117904 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 164 times.
 118074 return (dti->is_set_operation() && is_non_deterministic());
988 }
989
990 43 bool Item_func::check_column_in_window_functions(uchar *arg [[maybe_unused]]) {
991 // Pushing conditions having non-deterministic results must be done with
992 // care, or it may result in eliminating rows which would have
993 // otherwise contributed to aggregations.
994 // For Ex: SELECT * FROM (SELECT a AS x, SUM(b) FROM t1 GROUP BY a) dt
995 // WHERE x>5*RAND() AND x<3.
996 // In this case, x<3 is pushed to the WHERE clause of the derived table
997 // because there is grouping on "a". If we did the same for the random
998 // condition, this condition might reduce the number of rows that get
999 // qualified for grouping, resulting in wrong values for SUM. Similarly for
1000 // window functions. So we refrain from pushing the random condition
1001 // past the last operation done in the derived table's
1002 // materialization. Therefore, if there are window functions we cannot push
1003 // to HAVING, and if there is GROUP BY we cannot push to WHERE.
1004 // See also Item_field::is_valid_for_pushdown().
1005 43 return is_non_deterministic();
1006 }
1007
1008 72 bool Item_func::check_column_in_group_by(uchar *arg [[maybe_unused]]) {
1009 72 return is_non_deterministic();
1010 }
1011
1012 170704 bool is_function_of_type(const Item *item, Item_func::Functype type) {
1013
2/2
✓ Branch 0 taken 46795 times.
✓ Branch 1 taken 123909 times.
 217499 return item->type() == Item::FUNC_ITEM &&
1014
2/2
✓ Branch 0 taken 4983 times.
✓ Branch 1 taken 41812 times.
 217499 down_cast<const Item_func *>(item)->functype() == type;
1015 }
1016
1017 99 bool contains_function_of_type(Item *item, Item_func::Functype type) {
1018
1/2
✓ Branch 0 taken 99 times.
✗ Branch 1 not taken.
 198 return WalkItem(item, enum_walk::PREFIX, [type](Item *inner_item) {
1019 187 return is_function_of_type(inner_item, type);
1020 198 });
1021 }
1022
1023 /**
1024 Return new Item_field if given expression matches GC
1025
1026 @see substitute_gc()
1027
1028 @param func Expression to be replaced
1029 @param fld GCs field
1030 @param type Result type to match with Field
1031 @param[out] found If given, just return found field, without Item_field
1032
1033 @returns
1034 item new Item_field for matched GC
1035 NULL otherwise
1036 */
1037
1038 1147 Item_field *get_gc_for_expr(const Item *func, Field *fld, Item_result type,
1039 Field **found) {
1040 1147 func = func->real_item();
1041 1147 Item *expr = fld->gcol_info->expr_item;
1042
1043 /*
1044 In the case where the generated column expression returns JSON and
1045 the predicate compares the values as strings, it is not safe to
1046 replace the expression with the generated column, since the
1047 indexed string values will be double-quoted. The generated column
1048 expression should use the JSON_UNQUOTE function to strip off the
1049 double-quotes in order to get a usable index for looking up
1050 strings. See also the comment below.
1051 */
1052
4/6
✓ Branch 0 taken 801 times.
✓ Branch 1 taken 346 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 801 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1147 times.
 1147 if (type == STRING_RESULT && expr->data_type() == MYSQL_TYPE_JSON)
1053 ✗ return nullptr;
1054
1055 /*
1056 In order to match expressions against a functional index's expression,
1057 it's needed to skip CAST(.. AS .. ) and potentially COLLATE from the latter.
1058 This can't be joined with striping json_unquote below, since we might need
1059 to skip it too in expression like:
1060 CAST(JSON_UNQUOTE(<expr>) AS CHAR(X))
1061
1062 Also skip unquoting function. This is needed to address JSON string
1063 comparison issue. All JSON_* functions return quoted strings. In
1064 order to create usable index, GC column expression has to include
1065 JSON_UNQUOTE function, e.g JSON_UNQUOTE(JSON_EXTRACT(..)).
1066 Hence, the unquoting function in column expression have to be
1067 skipped in order to correctly match GC expr to expr in
1068 WHERE condition. The exception is if user has explicitly used
1069 JSON_UNQUOTE in WHERE condition.
1070 */
1071
1072 4588 for (Item_func::Functype functype :
1073 {Item_func::COLLATE_FUNC, Item_func::TYPECAST_FUNC,
1074
2/2
✓ Branch 0 taken 3441 times.
✓ Branch 1 taken 1147 times.
 5735 Item_func::JSON_UNQUOTE_FUNC}) {
1075
5/6
✓ Branch 0 taken 3441 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1098 times.
✓ Branch 3 taken 2343 times.
✓ Branch 4 taken 1013 times.
✓ Branch 5 taken 2428 times.
 4539 if (is_function_of_type(expr, functype) &&
1076
3/4
✓ Branch 0 taken 1098 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1013 times.
✓ Branch 3 taken 85 times.
 1098 !is_function_of_type(func, functype)) {
1077
1/2
✓ Branch 0 taken 1013 times.
✗ Branch 1 not taken.
 1013 expr = down_cast<Item_func *>(expr)->get_arg(0);
1078 }
1079 }
1080
1081
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1147 times.
 1147 if (!expr->can_be_substituted_for_gc(fld->is_array())) {
1082 ✗ return nullptr;
1083 }
1084
1085 // JSON implementation always uses binary collation
1086 1147 bool bin_cmp = (expr->data_type() == MYSQL_TYPE_JSON);
1087
6/6
✓ Branch 0 taken 1035 times.
✓ Branch 1 taken 112 times.
✓ Branch 2 taken 847 times.
✓ Branch 3 taken 188 times.
✓ Branch 4 taken 847 times.
✓ Branch 5 taken 300 times.
 1147 if (type == fld->result_type() && func->eq(expr, bin_cmp)) {
1088
2/2
✓ Branch 0 taken 234 times.
✓ Branch 1 taken 613 times.
 847 if (found) {
1089 // Temporary mark the field in order to check correct value conversion
1090 234 fld->table->mark_column_used(fld, MARK_COLUMNS_TEMP);
1091 234 *found = fld;
1092 234 return nullptr;
1093 }
1094 // Mark field for read
1095 613 fld->table->mark_column_used(fld, MARK_COLUMNS_READ);
1096
2/4
✓ Branch 0 taken 613 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 613 times.
✗ Branch 3 not taken.
 613 Item_field *field = new Item_field(fld);
1097 613 return field;
1098 }
1099
2/2
✓ Branch 0 taken 49 times.
✓ Branch 1 taken 251 times.
 300 if (found) *found = nullptr;
1100 300 return nullptr;
1101 }
1102
1103 /**
1104 Attempt to substitute an expression with an equivalent generated
1105 column in a predicate.
1106
1107 @param expr the expression that should be substituted
1108 @param value if given, value will be coerced to GC field's type and
1109 the result will substitute the original value. Used by
1110 multi-valued index.
1111 @param gc_fields list of indexed generated columns to check for
1112 equivalence with the expression
1113 @param type the acceptable type of the generated column that
1114 replaces the expression
1115 @param predicate the predicate in which the substitution is done
1116
1117 @return true on error, false on success
1118 */
1119 762 static bool substitute_gc_expression(Item **expr, Item **value,
1120 List<Field> *gc_fields, Item_result type,
1121 Item_func *predicate) {
1122
1/2
✓ Branch 0 taken 762 times.
✗ Branch 1 not taken.
 762 List_iterator<Field> li(*gc_fields);
1123 762 Item_field *item_field = nullptr;
1124
2/2
✓ Branch 0 taken 874 times.
✓ Branch 1 taken 150 times.
 1024 while (Field *field = li++) {
1125 // Check whether the field has usable keys.
1126 874 Key_map tkm = field->part_of_key;
1127 874 tkm.merge(field->part_of_prefixkey); // Include prefix keys.
1128 874 tkm.intersect(field->table->keys_in_use_for_query);
1129 /*
1130 Don't substitute if:
1131 1) Key is disabled
1132 2) It's a multi-valued index's field and predicate isn't MEMBER OF
1133 */
1134
4/4
✓ Branch 0 taken 860 times.
✓ Branch 1 taken 14 times.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 856 times.
 1734 if (tkm.is_clear_all() || // (1)
1135
6/8
✓ Branch 0 taken 860 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 552 times.
✓ Branch 3 taken 308 times.
✓ Branch 4 taken 552 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✓ Branch 7 taken 548 times.
 860 (field->is_array() && predicate->functype() != // (2)
1136 Item_func::MEMBER_OF_FUNC))
1137 18 continue;
1138 // If the field is a hidden field used by a functional index, we require
1139 // that the collation of the field must match the collation of the
1140 // expression. If not, we might end up with the wrong result when using
1141 // the index (see bug#27337092). Ideally, this should be done for normal
1142 // generated columns as well, but that is delayed to a later fix since the
1143 // impact might be quite large.
1144
4/4
✓ Branch 0 taken 617 times.
✓ Branch 1 taken 239 times.
✓ Branch 2 taken 851 times.
✓ Branch 3 taken 5 times.
 1473 if (!(field->is_field_for_functional_index() &&
1145
3/4
✓ Branch 0 taken 617 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 599 times.
 617 field->match_collation_to_optimize_range() &&
1146
3/4
✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 5 times.
 18 (*expr)->collation.collation != field->charset())) {
1147
1/2
✓ Branch 0 taken 851 times.
✗ Branch 1 not taken.
 851 item_field = get_gc_for_expr(*expr, field, type);
1148
2/2
✓ Branch 0 taken 612 times.
✓ Branch 1 taken 239 times.
 851 if (item_field != nullptr) break;
1149 }
1150 262 }
1151
1152
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 612 times.
 762 if (item_field == nullptr) return false;
1153
1154 // A matching expression is found. Substitute the expression with
1155 // the matching generated column.
1156
1/2
✓ Branch 0 taken 612 times.
✗ Branch 1 not taken.
 612 THD *thd = current_thd;
1157
6/8
✓ Branch 0 taken 612 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 464 times.
✓ Branch 3 taken 148 times.
✓ Branch 4 taken 464 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 464 times.
✓ Branch 7 taken 148 times.
 612 if (item_field->returns_array() && value) {
1158 464 Json_wrapper wr;
1159 464 String str_val, buf;
1160 464 Field_typed_array *afld = down_cast<Field_typed_array *>(item_field->field);
1161
1162
1/2
✓ Branch 0 taken 464 times.
✗ Branch 1 not taken.
 464 Functional_index_error_handler functional_index_error_handler(afld, thd);
1163
1164
2/4
✓ Branch 0 taken 464 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 464 times.
 464 if (get_json_atom_wrapper(value, 0, "MEMBER OF", &str_val, &buf, &wr,
1165 nullptr, true))
1166 ✗ return true;
1167
1168 464 auto to_wr = make_unique_destroy_only<Json_wrapper>(thd->mem_root);
1169
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 464 times.
 464 if (to_wr == nullptr) return true;
1170
1171 // Don't substitute if value can't be coerced to field's type
1172
3/4
✓ Branch 0 taken 464 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 462 times.
 464 if (afld->coerce_json_value(&wr, /*no_error=*/true, to_wr.get()))
1173 2 return false;
1174
1175 Item_json *jsn =
1176
2/4
✓ Branch 0 taken 462 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 462 times.
✗ Branch 3 not taken.
 462 new (thd->mem_root) Item_json(std::move(to_wr), predicate->item_name);
1177
4/8
✓ Branch 0 taken 462 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 462 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 462 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 462 times.
 462 if (jsn == nullptr || jsn->fix_fields(thd, nullptr)) return true;
1178
1/2
✓ Branch 0 taken 462 times.
✗ Branch 1 not taken.
 462 thd->change_item_tree(value, jsn);
1179
10/10
✓ Branch 0 taken 462 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 462 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 462 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 462 times.
✓ Branch 7 taken 2 times.
✓ Branch 8 taken 462 times.
✓ Branch 9 taken 2 times.
 472 }
1180
1/2
✓ Branch 0 taken 610 times.
✗ Branch 1 not taken.
 610 thd->change_item_tree(expr, item_field);
1181
1182 // Adjust the predicate.
1183
1/2
✓ Branch 0 taken 610 times.
✗ Branch 1 not taken.
 610 return predicate->resolve_type(thd);
1184 }
1185
1186 /**
1187 A helper function for Item_func::gc_subst_transformer, that tries to
1188 substitute the given JSON_CONTAINS or JSON_OVERLAPS function for one of GCs
1189 from the provided list. The function checks whether there's an index with
1190 matching expression and whether all scalars for lookup can be coerced to
1191 index's GC field without errors. If so, index's GC field substitutes the
1192 given function, args are replaced for array of coerced values in order to
1193 match GC's type. substitute_gc_expression() can't be used to these functions
1194 as it's tailored to handle regular single-valued indexes and doesn't ensure
1195 correct coercion of all values to lookup in multi-valued index.
1196
1197 @param func Function to replace
1198 @param vals Args to replace
1199 @param vals_wr Json_wrapper containing array of values for index lookup
1200 @param gc_fields List of generated fields to look the function's substitute in
1201 */
1202
1203 257 static void gc_subst_overlaps_contains(Item **func, Item **vals,
1204 Json_wrapper &vals_wr,
1205 List<Field> *gc_fields) {
1206 // Field to substitute function for. NULL when no matching index was found.
1207 257 Field *found = nullptr;
1208
4/8
✓ Branch 0 taken 257 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 257 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 257 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 257 times.
✗ Branch 7 not taken.
 257 assert(vals_wr.type() != enum_json_type::J_OBJECT &&
1209 vals_wr.type() != enum_json_type::J_ERROR);
1210
1/2
✓ Branch 0 taken 257 times.
✗ Branch 1 not taken.
 257 THD *thd = current_thd;
1211 // Vector of coerced keys
1212
1/2
✓ Branch 0 taken 257 times.
✗ Branch 1 not taken.
 257 Json_array_ptr coerced_keys = create_dom_ptr<Json_array>();
1213
1214 // Find a field that matches the expression
1215
5/8
✓ Branch 0 taken 257 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 257 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 395 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 369 times.
✓ Branch 7 taken 26 times.
 395 for (Field &fld : *gc_fields) {
1216 369 bool can_use_index = true;
1217 // Check whether field has usable keys
1218 369 Key_map tkm = fld.part_of_key;
1219 369 tkm.intersect(fld.table->keys_in_use_for_query);
1220
1221
7/8
✓ Branch 0 taken 356 times.
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 356 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 73 times.
✓ Branch 5 taken 283 times.
✓ Branch 6 taken 86 times.
✓ Branch 7 taken 283 times.
 418 if (tkm.is_clear_all() || !fld.is_array()) continue;
1222
1/2
✓ Branch 0 taken 283 times.
✗ Branch 1 not taken.
 283 Functional_index_error_handler func_idx_err_hndl(&fld, thd);
1223 283 found = nullptr;
1224
1225
2/4
✓ Branch 0 taken 283 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 283 times.
✗ Branch 3 not taken.
 283 get_gc_for_expr(*func, &fld, fld.result_type(), &found);
1226
6/8
✓ Branch 0 taken 234 times.
✓ Branch 1 taken 49 times.
✓ Branch 2 taken 234 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 234 times.
✓ Branch 6 taken 49 times.
✓ Branch 7 taken 234 times.
 283 if (!found || !found->is_array()) continue;
1227 234 Field_typed_array *afld = down_cast<Field_typed_array *>(found);
1228 // Check that array's values can be coerced to found field's type
1229 uint len;
1230
3/4
✓ Branch 0 taken 234 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 142 times.
✓ Branch 3 taken 92 times.
 234 if (vals_wr.type() == enum_json_type::J_ARRAY)
1231
1/2
✓ Branch 0 taken 142 times.
✗ Branch 1 not taken.
 142 len = vals_wr.length();
1232 else
1233 92 len = 1;
1234 234 coerced_keys->clear();
1235
2/2
✓ Branch 0 taken 377 times.
✓ Branch 1 taken 231 times.
 608 for (uint i = 0; i < len; i++) {
1236
1/2
✓ Branch 0 taken 377 times.
✗ Branch 1 not taken.
 377 Json_wrapper elt = vals_wr[i];
1237 377 Json_wrapper res;
1238
3/4
✓ Branch 0 taken 377 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 374 times.
 377 if (afld->coerce_json_value(&elt, true, &res)) {
1239 3 can_use_index = false;
1240 3 found = nullptr;
1241 3 break;
1242 }
1243
2/4
✓ Branch 0 taken 374 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 374 times.
✗ Branch 3 not taken.
 374 coerced_keys->append_clone(res.to_dom());
1244
4/4
✓ Branch 0 taken 374 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 374 times.
✓ Branch 3 taken 3 times.
 380 }
1245
2/2
✓ Branch 0 taken 231 times.
✓ Branch 1 taken 3 times.
 234 if (can_use_index) break;
1246
3/3
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 49 times.
✓ Branch 2 taken 231 times.
 283 }
1247
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 231 times.
 257 if (!found) return;
1248 231 TABLE *table = found->table;
1249
2/4
✓ Branch 0 taken 231 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 231 times.
✗ Branch 3 not taken.
 231 Item_field *subs_item = new Item_field(found);
1250
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 231 times.
 231 if (!subs_item) return;
1251 auto res = make_unique_destroy_only<Json_wrapper>(thd->mem_root,
1252
1/2
✓ Branch 0 taken 231 times.
✗ Branch 1 not taken.
 231 coerced_keys.release());
1253
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 231 times.
 231 if (res == nullptr) return;
1254 Item_json *array_arg =
1255
2/4
✓ Branch 0 taken 231 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 231 times.
✗ Branch 3 not taken.
 231 new (thd->mem_root) Item_json(std::move(res), (*func)->item_name);
1256
4/8
✓ Branch 0 taken 231 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 231 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 231 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 231 times.
 231 if (!array_arg || array_arg->fix_fields(thd, nullptr)) return;
1257
1/2
✓ Branch 0 taken 231 times.
✗ Branch 1 not taken.
 231 table->mark_column_used(found, MARK_COLUMNS_READ);
1258
1/2
✓ Branch 0 taken 231 times.
✗ Branch 1 not taken.
 231 thd->change_item_tree(func, subs_item);
1259
1/2
✓ Branch 0 taken 231 times.
✗ Branch 1 not taken.
 231 thd->change_item_tree(vals, array_arg);
1260
3/4
✓ Branch 0 taken 231 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 231 times.
✓ Branch 3 taken 26 times.
 257 }
1261
1262 /**
1263 Transformer function for GC substitution.
1264
1265 @param arg List of indexed GC field
1266
1267 @return this item on successful execution, nullptr on error
1268
1269 @details This function transforms a search condition. It doesn't change
1270 'this' item but rather changes its arguments. It takes list of GC fields
1271 and checks whether arguments of 'this' item matches them and index over
1272 the GC field isn't disabled with hints. If so, it replaces
1273 the argument with newly created Item_field which uses the matched GC field.
1274 The following predicates' arguments could be transformed:
1275 - EQ_FUNC, LT_FUNC, LE_FUNC, GE_FUNC, GT_FUNC, JSON_OVERLAPS
1276 - Left _or_ right argument if the opposite argument is a constant.
1277 - IN_FUNC, BETWEEN
1278 - Left argument if all other arguments are constant and of the same type.
1279 - MEMBER OF
1280 - Right argument if left argument is constant.
1281 - JSON_CONTAINS
1282 - First argument if the second argument is constant.
1283
1284 After transformation comparators are updated to take into account the new
1285 field.
1286
1287 Note: Range optimizer is used with multi-value indexes and it prefers
1288 constants. Outer references are not considered as constants in JSON functions.
1289 However, range optimizer supports dynamic ranges, where ranges are
1290 re-optimized for each row. But the range optimizer is currently not able to
1291 handle multi-valued indexes with dynamic ranges, hence we use only constants
1292 in these cases.
1293
1294 */
1295
1296 24173 Item *Item_func::gc_subst_transformer(uchar *arg) {
1297 24173 List<Field> *gc_fields = pointer_cast<List<Field> *>(arg);
1298
1299 307 auto is_const_or_outer_reference = [](const Item *item) {
1300 307 return ((item->used_tables() & ~(OUTER_REF_TABLE_BIT | INNER_TABLE_BIT)) ==
1301 307 0);
1302 };
1303
1304
7/8
✓ Branch 0 taken 24173 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23174 times.
✓ Branch 3 taken 82 times.
✓ Branch 4 taken 481 times.
✓ Branch 5 taken 164 times.
✓ Branch 6 taken 112 times.
✓ Branch 7 taken 160 times.
 24173 switch (functype()) {
1305 23174 case EQ_FUNC:
1306 case LT_FUNC:
1307 case LE_FUNC:
1308 case GE_FUNC:
1309 case GT_FUNC: {
1310 23174 Item **func = nullptr;
1311 23174 Item *val = nullptr;
1312
1313 // Check if we can substitute a function with a GC. The
1314 // predicate must be on the form <expr> OP <constant> or
1315 // <constant> OP <expr>.
1316
5/6
✓ Branch 0 taken 23174 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 264 times.
✓ Branch 3 taken 22910 times.
✓ Branch 4 taken 264 times.
✓ Branch 5 taken 22910 times.
 23438 if (args[0]->can_be_substituted_for_gc() &&
1317
2/4
✓ Branch 0 taken 264 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 264 times.
✗ Branch 3 not taken.
 264 is_const_or_outer_reference(args[1])) {
1318 264 func = args;
1319 264 val = args[1];
1320
5/6
✓ Branch 0 taken 22910 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 27 times.
✓ Branch 3 taken 22883 times.
✓ Branch 4 taken 15 times.
✓ Branch 5 taken 22895 times.
 22937 } else if (args[1]->can_be_substituted_for_gc() &&
1321
3/4
✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 12 times.
 27 is_const_or_outer_reference(args[0])) {
1322 15 func = args + 1;
1323 15 val = args[0];
1324 } else {
1325 22895 break;
1326 }
1327
1328
3/6
✓ Branch 0 taken 279 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 279 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 279 times.
 279 if (substitute_gc_expression(func, nullptr, gc_fields, val->result_type(),
1329 this))
1330 ✗ return nullptr; /* purecov: inspected */
1331 279 break;
1332 }
1333 82 case BETWEEN:
1334 case IN_FUNC: {
1335
3/4
✓ Branch 0 taken 82 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 76 times.
✓ Branch 3 taken 6 times.
 82 if (!args[0]->can_be_substituted_for_gc()) break;
1336
1337 // Can only substitute if all the operands on the right-hand
1338 // side are constants of the same type.
1339
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 Item_result type = args[1]->result_type();
1340
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!std::all_of(
1341
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 args + 1, args + arg_count,
1342 32 [type, is_const_or_outer_reference](const Item *item_arg) {
1343
1/2
✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
 32 return is_const_or_outer_reference(item_arg) &&
1344
1/2
✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
 32 item_arg->result_type() == type;
1345 })) {
1346 ✗ break;
1347 }
1348
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
 6 if (substitute_gc_expression(args, nullptr, gc_fields, type, this))
1349 ✗ return nullptr;
1350 6 break;
1351 }
1352 481 case MEMBER_OF_FUNC: {
1353
1/2
✓ Branch 0 taken 481 times.
✗ Branch 1 not taken.
 481 Item_result type = args[0]->result_type();
1354 /*
1355 Check whether MEMBER OF is applicable for optimization:
1356 1) 1st arg is constant for execution
1357 2) .. and it isn't NULL, as MEMBER OF can't be used to lookup NULLs
1358 3) 2nd arg can be substituted for a GC
1359 */
1360
1/2
✓ Branch 0 taken 481 times.
✗ Branch 1 not taken.
 481 if (args[0]->const_for_execution() && // 1
1361
7/8
✓ Branch 0 taken 479 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 479 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 477 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 477 times.
✓ Branch 7 taken 4 times.
 958 !args[0]->is_null() && // 2
1362
2/4
✓ Branch 0 taken 477 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 477 times.
✗ Branch 3 not taken.
 477 args[1]->can_be_substituted_for_gc(/*array=*/true)) { // 3
1363
2/4
✓ Branch 0 taken 477 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 477 times.
 477 if (substitute_gc_expression(args + 1, args, gc_fields, type, this))
1364 ✗ return nullptr;
1365 }
1366 481 break;
1367 }
1368 164 case JSON_CONTAINS: {
1369 164 Json_wrapper vals_wr;
1370 164 String str;
1371 /*
1372 Check whether JSON_CONTAINS is applicable for optimization:
1373 1) 1st arg can be substituted with a generated column
1374 2) value to lookup is constant for execution
1375 3) value to lookup is a proper JSON doc
1376 4) value to lookup is an array or scalar
1377 */
1378
4/6
✓ Branch 0 taken 164 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 164 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 13 times.
✓ Branch 5 taken 151 times.
 328 if (!args[0]->can_be_substituted_for_gc(/*array=*/true) || // 1
1379
3/4
✓ Branch 0 taken 164 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 151 times.
 164 !args[1]->const_for_execution()) // 2
1380 13 break;
1381
4/6
✓ Branch 0 taken 151 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 151 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 150 times.
 151 if (get_json_wrapper(args, 1, &str, func_name(), &vals_wr)) { // 3
1382 1 return nullptr;
1383 }
1384
3/4
✓ Branch 0 taken 150 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 147 times.
 300 if (args[1]->null_value ||
1385
3/4
✓ Branch 0 taken 150 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 147 times.
 150 vals_wr.type() == enum_json_type::J_OBJECT) // 4
1386 3 break;
1387
1/2
✓ Branch 0 taken 147 times.
✗ Branch 1 not taken.
 147 gc_subst_overlaps_contains(args, args + 1, vals_wr, gc_fields);
1388 147 break;
1389
4/4
✓ Branch 0 taken 163 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 163 times.
✓ Branch 3 taken 1 times.
 328 }
1390 112 case JSON_OVERLAPS: {
1391 112 Item **func = nullptr;
1392 112 int vals = -1;
1393
1394 /*
1395 Check whether JSON_OVERLAPS is applicable for optimization:
1396 1) One argument is constant for execution
1397 2) The other argument can be substituted with a generated column
1398 3) value to lookup is a proper JSON doc
1399 4) value to lookup is an array or scalar
1400 */
1401
5/6
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 104 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 91 times.
✓ Branch 5 taken 21 times.
 216 if (args[0]->can_be_substituted_for_gc(/*array=*/true) && // 2
1402
3/4
✓ Branch 0 taken 104 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 91 times.
✓ Branch 3 taken 13 times.
 104 args[1]->const_for_execution()) { // 1
1403 91 func = args;
1404 91 vals = 1;
1405
3/6
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 21 times.
✗ Branch 5 not taken.
 42 } else if (args[1]->can_be_substituted_for_gc(/*array=*/true) && // 2
1406
2/4
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
 21 args[0]->const_for_execution()) { // 1
1407 21 func = args + 1;
1408 21 vals = 0;
1409 } else {
1410 111 break;
1411 }
1412
1413 112 Json_wrapper vals_wr;
1414 112 String str;
1415
4/6
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 112 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 111 times.
 112 if (get_json_wrapper(args, vals, &str, func_name(), &vals_wr)) { // 3
1416 1 return nullptr;
1417 }
1418
3/4
✓ Branch 0 taken 111 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 110 times.
 222 if (args[vals]->null_value ||
1419
3/4
✓ Branch 0 taken 111 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 110 times.
 111 vals_wr.type() == enum_json_type::J_OBJECT) // 4
1420 1 break;
1421
1/2
✓ Branch 0 taken 110 times.
✗ Branch 1 not taken.
 110 gc_subst_overlaps_contains(func, args + vals, vals_wr, gc_fields);
1422 110 break;
1423
4/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 111 times.
✓ Branch 2 taken 111 times.
✓ Branch 3 taken 1 times.
 224 }
1424 160 default:
1425 160 break;
1426 }
1427 24171 return this;
1428 }
1429
1430 824 double Item_int_func::val_real() {
1431
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 824 times.
 824 assert(fixed == 1);
1432
1433
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 820 times.
 824 return unsigned_flag ? (double)((ulonglong)val_int()) : (double)val_int();
1434 }
1435
1436 3004516 String *Item_int_func::val_str(String *str) {
1437
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3004516 times.
 3004516 assert(fixed == 1);
1438 3004516 longlong nr = val_int();
1439
2/2
✓ Branch 0 taken 356 times.
✓ Branch 1 taken 3004160 times.
 3004516 if (null_value) return nullptr;
1440 3004160 str->set_int(nr, unsigned_flag, collation.collation);
1441 3004160 return str;
1442 }
1443
1444 11247 bool Item_func_connection_id::itemize(Parse_context *pc, Item **res) {
1445
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11247 times.
 11247 if (skip_itemize(res)) return false;
1446
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11247 times.
 11247 if (super::itemize(pc, res)) return true;
1447 11247 pc->thd->lex->safe_to_cache_query = false;
1448 11247 return false;
1449 }
1450
1451 2493 bool Item_func_connection_id::resolve_type(THD *thd) {
1452
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2493 times.
 2493 if (Item_int_func::resolve_type(thd)) return true;
1453 2493 unsigned_flag = true;
1454 2493 return false;
1455 }
1456
1457 2493 bool Item_func_connection_id::fix_fields(THD *thd, Item **ref) {
1458
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2494 times.
 2493 if (Item_int_func::fix_fields(thd, ref)) return true;
1459 2494 thd->thread_specific_used = true;
1460 2494 return false;
1461 }
1462
1463 6354 longlong Item_func_connection_id::val_int() {
1464
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6354 times.
 6354 assert(fixed);
1465 6354 return current_thd->variables.pseudo_thread_id;
1466 }
1467
1468 /**
1469 Check arguments to determine the data type for a numeric
1470 function of two arguments.
1471 */
1472
1473 3371036 void Item_num_op::set_numeric_type(void) {
1474
1/2
✓ Branch 0 taken 3371049 times.
✗ Branch 1 not taken.
 3371036 DBUG_TRACE;
1475
3/10
✓ Branch 0 taken 3371051 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3371049 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3371049 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 3371049 DBUG_PRINT("info", ("name %s", func_name()));
1476
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3371049 times.
 3371049 assert(arg_count == 2);
1477
1/2
✓ Branch 0 taken 3371046 times.
✗ Branch 1 not taken.
 3371049 Item_result r0 = args[0]->numeric_context_result_type();
1478
1/2
✓ Branch 0 taken 3371043 times.
✗ Branch 1 not taken.
 3371046 Item_result r1 = args[1]->numeric_context_result_type();
1479
1480
2/4
✓ Branch 0 taken 3371045 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3371045 times.
✗ Branch 3 not taken.
 3371043 assert(r0 != STRING_RESULT && r1 != STRING_RESULT);
1481
1482
4/4
✓ Branch 0 taken 3218446 times.
✓ Branch 1 taken 152599 times.
✓ Branch 2 taken 42971 times.
✓ Branch 3 taken 3175475 times.
 3371045 if (r0 == REAL_RESULT || r1 == REAL_RESULT) {
1483 /*
1484 Since DATE/TIME/DATETIME data types return INT_RESULT/DECIMAL_RESULT
1485 type codes, we should never get to here when both fields are temporal.
1486 */
1487
3/4
✓ Branch 0 taken 66 times.
✓ Branch 1 taken 195495 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 66 times.
 195570 assert(!args[0]->is_temporal() || !args[1]->is_temporal());
1488 195561 set_data_type(MYSQL_TYPE_DOUBLE);
1489 195561 hybrid_type = REAL_RESULT;
1490
1/2
✓ Branch 0 taken 195561 times.
✗ Branch 1 not taken.
 195561 aggregate_float_properties(args, arg_count);
1491 195561 max_length = float_length(decimals);
1492
4/4
✓ Branch 0 taken 3048899 times.
✓ Branch 1 taken 126576 times.
✓ Branch 2 taken 17691 times.
✓ Branch 3 taken 3031208 times.
 3175475 } else if (r0 == DECIMAL_RESULT || r1 == DECIMAL_RESULT) {
1493 144267 set_data_type(MYSQL_TYPE_NEWDECIMAL);
1494 144268 hybrid_type = DECIMAL_RESULT;
1495
1/2
✓ Branch 0 taken 144268 times.
✗ Branch 1 not taken.
 144268 result_precision();
1496 } else {
1497
2/4
✓ Branch 0 taken 3031214 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3031214 times.
✗ Branch 3 not taken.
 3031208 assert(r0 == INT_RESULT && r1 == INT_RESULT);
1498 3031214 set_data_type(MYSQL_TYPE_LONGLONG);
1499 3031217 decimals = 0;
1500 3031217 hybrid_type = INT_RESULT;
1501
1/2
✓ Branch 0 taken 3031217 times.
✗ Branch 1 not taken.
 3031217 result_precision();
1502 }
1503
3/14
✓ Branch 0 taken 3371044 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3371045 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3371045 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
 3371046 DBUG_PRINT("info", ("Type: %s", (hybrid_type == REAL_RESULT
1504 ? "REAL_RESULT"
1505 : hybrid_type == DECIMAL_RESULT
1506 ? "DECIMAL_RESULT"
1507 : hybrid_type == INT_RESULT
1508 ? "INT_RESULT"
1509 : "--ILLEGAL!!!--")));
1510 3371045 }
1511
1512 /**
1513 Set data type for a numeric function with one argument
1514 (can be also used by a numeric function with many arguments, if the result
1515 type depends only on the first argument)
1516 */
1517
1518 146132 void Item_func_num1::set_numeric_type() {
1519
1/2
✓ Branch 0 taken 146133 times.
✗ Branch 1 not taken.
 146132 DBUG_TRACE;
1520
3/10
✓ Branch 0 taken 146133 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 146133 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 146133 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 146133 DBUG_PRINT("info", ("name %s", func_name()));
1521
4/6
✓ Branch 0 taken 146132 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 142363 times.
✓ Branch 3 taken 1433 times.
✓ Branch 4 taken 2336 times.
✗ Branch 5 not taken.
 146133 switch (hybrid_type = args[0]->result_type()) {
1522 142363 case INT_RESULT:
1523 142363 set_data_type(MYSQL_TYPE_LONGLONG);
1524 142364 unsigned_flag = args[0]->unsigned_flag;
1525 142364 break;
1526 1433 case STRING_RESULT:
1527 case REAL_RESULT:
1528 1433 set_data_type(MYSQL_TYPE_DOUBLE);
1529 1433 hybrid_type = REAL_RESULT;
1530 1433 max_length = float_length(decimals);
1531 1433 break;
1532 2336 case DECIMAL_RESULT:
1533 2336 set_data_type(MYSQL_TYPE_NEWDECIMAL);
1534 2336 unsigned_flag = args[0]->unsigned_flag;
1535 2336 break;
1536 ✗ default:
1537 ✗ assert(0);
1538 }
1539
3/14
✓ Branch 0 taken 146133 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 146133 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 146133 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
 146133 DBUG_PRINT("info", ("Type: %s", (hybrid_type == REAL_RESULT
1540 ? "REAL_RESULT"
1541 : hybrid_type == DECIMAL_RESULT
1542 ? "DECIMAL_RESULT"
1543 : hybrid_type == INT_RESULT
1544 ? "INT_RESULT"
1545 : "--ILLEGAL!!!--")));
1546 146133 }
1547
1548 2575 void Item_func_num1::fix_num_length_and_dec() {
1549 2575 decimals = args[0]->decimals;
1550 2575 max_length = args[0]->max_length;
1551 2575 }
1552
1553 /*
1554 Reject geometry arguments, should be called in resolve_type() for
1555 SQL functions/operators where geometries are not suitable as operands.
1556 */
1557 7645009 bool reject_geometry_args(uint arg_count, Item **args, Item_result_field *me) {
1558 /*
1559 We want to make sure the operands are not GEOMETRY strings because
1560 it's meaningless for them to participate in arithmetic and/or numerical
1561 calculations.
1562
1563 When a variable holds a MySQL Geometry byte string, it is regarded as a
1564 string rather than a MYSQL_TYPE_GEOMETRY, so here we can't catch an illegal
1565 variable argument which was assigned with a geometry.
1566
1567 Item::data_type() requires the item not be of ROW_RESULT, since a row
1568 isn't a field.
1569 */
1570
2/2
✓ Branch 0 taken 13068476 times.
✓ Branch 1 taken 7644920 times.
 20713396 for (uint i = 0; i < arg_count; i++) {
1571
6/6
✓ Branch 0 taken 13068363 times.
✓ Branch 1 taken 118 times.
✓ Branch 2 taken 97 times.
✓ Branch 3 taken 13068269 times.
✓ Branch 4 taken 97 times.
✓ Branch 5 taken 13068387 times.
 26136842 if (args[i]->result_type() != ROW_RESULT &&
1572 13068363 args[i]->data_type() == MYSQL_TYPE_GEOMETRY) {
1573 97 my_error(ER_WRONG_ARGUMENTS, MYF(0), me->func_name());
1574 97 return true;
1575 }
1576 }
1577
1578 7644920 return false;
1579 }
1580
1581 /**
1582 Go through the arguments of a function and check if any of them are
1583 JSON. If a JSON argument is found, raise a warning saying that this
1584 operation is not supported yet. This function is used to notify
1585 users that they are comparing JSON values using a mechanism that has
1586 not yet been updated to use the JSON comparator. JSON values are
1587 typically handled as strings in that case.
1588
1589 @param arg_count the number of arguments
1590 @param args the arguments to go through looking for JSON values
1591 @param msg the message that explains what is not supported
1592 */
1593 20752 void unsupported_json_comparison(size_t arg_count, Item **args,
1594 const char *msg) {
1595
2/2
✓ Branch 0 taken 59185 times.
✓ Branch 1 taken 20749 times.
 79934 for (size_t i = 0; i < arg_count; ++i) {
1596
6/6
✓ Branch 0 taken 4078 times.
✓ Branch 1 taken 55107 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 4075 times.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 59182 times.
 63263 if (args[i]->result_type() == STRING_RESULT &&
1597 4078 args[i]->data_type() == MYSQL_TYPE_JSON) {
1598 3 push_warning_printf(current_thd, Sql_condition::SL_WARNING,
1599 ER_NOT_SUPPORTED_YET,
1600 3 ER_THD(current_thd, ER_NOT_SUPPORTED_YET), msg);
1601 3 break;
1602 }
1603 }
1604 20752 }
1605
1606 4478449 bool Item_func_numhybrid::resolve_type(THD *thd) {
1607
3/4
✓ Branch 0 taken 4220671 times.
✓ Branch 1 taken 257778 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4220671 times.
 4478449 assert(arg_count == 1 || arg_count == 2);
1608 /*
1609 If no arguments have type information, return and trust
1610 propagate_type() to assign data types later.
1611 If some argument has type information, propagate the same type to
1612 the other argument.
1613 */
1614
2/2
✓ Branch 0 taken 257778 times.
✓ Branch 1 taken 4220671 times.
 4478449 if (arg_count == 1) {
1615
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 257767 times.
 257778 if (args[0]->data_type() == MYSQL_TYPE_INVALID) return false;
1616 } else {
1617
6/6
✓ Branch 0 taken 51 times.
✓ Branch 1 taken 4220621 times.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 33 times.
✓ Branch 4 taken 18 times.
✓ Branch 5 taken 4220654 times.
 4220722 if (args[0]->data_type() == MYSQL_TYPE_INVALID &&
1618 51 args[1]->data_type() == MYSQL_TYPE_INVALID)
1619 18 return false;
1620
1621
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 4220623 times.
 4220654 if (args[0]->data_type() == MYSQL_TYPE_INVALID) {
1622
2/4
✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 33 times.
 33 if (args[0]->propagate_type(thd, Type_properties(*args[1]))) return true;
1623
2/2
✓ Branch 0 taken 267 times.
✓ Branch 1 taken 4220356 times.
 4220623 } else if (args[1]->data_type() == MYSQL_TYPE_INVALID) {
1624
2/4
✓ Branch 0 taken 267 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 267 times.
 267 if (args[1]->propagate_type(thd, Type_properties(*args[0]))) return true;
1625 }
1626 }
1627
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 4478424 times.
 4478423 if (resolve_type_inner(thd)) return true;
1628 4478424 return reject_geometry_args(arg_count, args, this);
1629 }
1630
1631 4366800 bool Item_func_numhybrid::resolve_type_inner(THD *) {
1632
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4366807 times.
 4366800 assert(args[0]->data_type() != MYSQL_TYPE_INVALID);
1633
3/4
✓ Branch 0 taken 4220677 times.
✓ Branch 1 taken 146130 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4220678 times.
 4366807 assert(arg_count == 1 || args[1]->data_type() != MYSQL_TYPE_INVALID);
1634 4366808 fix_num_length_and_dec();
1635 4366797 set_numeric_type();
1636 4366811 return false;
1637 }
1638
1639 8725500 String *Item_func_numhybrid::val_str(String *str) {
1640
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8725500 times.
 8725500 assert(fixed == 1);
1641
4/5
✓ Branch 0 taken 30412 times.
✓ Branch 1 taken 199874 times.
✓ Branch 2 taken 17479 times.
✓ Branch 3 taken 8477735 times.
✗ Branch 4 not taken.
 8725500 switch (hybrid_type) {
1642 30412 case DECIMAL_RESULT: {
1643 30412 my_decimal decimal_value, *val;
1644
3/4
✓ Branch 0 taken 30412 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5254 times.
✓ Branch 3 taken 25158 times.
 30412 if (!(val = decimal_op(&decimal_value))) return nullptr; // null is set
1645
1/2
✓ Branch 0 taken 25158 times.
✗ Branch 1 not taken.
 25158 my_decimal_round(E_DEC_FATAL_ERROR, val, decimals, false, val);
1646 25158 str->set_charset(collation.collation);
1647
1/2
✓ Branch 0 taken 25158 times.
✗ Branch 1 not taken.
 25158 my_decimal2string(E_DEC_FATAL_ERROR, val, str);
1648 25158 break;
1649
2/2
✓ Branch 0 taken 5254 times.
✓ Branch 1 taken 25158 times.
 30412 }
1650 199874 case INT_RESULT: {
1651 199874 longlong nr = int_op();
1652
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 199834 times.
 199874 if (null_value) return nullptr; /* purecov: inspected */
1653 199834 str->set_int(nr, unsigned_flag, collation.collation);
1654 199834 break;
1655 }
1656 17479 case REAL_RESULT: {
1657 17479 double nr = real_op();
1658
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17479 times.
 17479 if (null_value) return nullptr; /* purecov: inspected */
1659 17479 str->set_real(nr, decimals, collation.collation);
1660 17479 break;
1661 }
1662 8477735 case STRING_RESULT:
1663
4/4
✓ Branch 0 taken 45 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 8477669 times.
 8477735 switch (data_type()) {
1664 45 case MYSQL_TYPE_DATETIME:
1665 case MYSQL_TYPE_TIMESTAMP:
1666 45 return val_string_from_datetime(str);
1667 16 case MYSQL_TYPE_DATE:
1668 16 return val_string_from_date(str);
1669 5 case MYSQL_TYPE_TIME:
1670 5 return val_string_from_time(str);
1671 8477669 default:
1672 8477669 break;
1673 }
1674 8477669 return str_op(&str_value);
1675 ✗ default:
1676 ✗ assert(0);
1677 }
1678 242471 return str;
1679 }
1680
1681 3645173 double Item_func_numhybrid::val_real() {
1682
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3645173 times.
 3645173 assert(fixed == 1);
1683
4/5
✓ Branch 0 taken 329486 times.
✓ Branch 1 taken 212345 times.
✓ Branch 2 taken 3103329 times.
✓ Branch 3 taken 18 times.
✗ Branch 4 not taken.
 3645173 switch (hybrid_type) {
1684 329486 case DECIMAL_RESULT: {
1685 329486 my_decimal decimal_value, *val;
1686 double result;
1687
3/4
✓ Branch 0 taken 329486 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84 times.
✓ Branch 3 taken 329402 times.
 329486 if (!(val = decimal_op(&decimal_value))) return 0.0; // null is set
1688
1/2
✓ Branch 0 taken 329402 times.
✗ Branch 1 not taken.
 329402 my_decimal2double(E_DEC_FATAL_ERROR, val, &result);
1689 329402 return result;
1690 329486 }
1691 212345 case INT_RESULT: {
1692 212345 longlong result = int_op();
1693
2/2
✓ Branch 0 taken 2285 times.
✓ Branch 1 taken 210060 times.
 212345 return unsigned_flag ? (double)((ulonglong)result) : (double)result;
1694 }
1695 3103329 case REAL_RESULT:
1696 3103329 return real_op();
1697 18 case STRING_RESULT: {
1698
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 14 times.
 18 switch (data_type()) {
1699 4 case MYSQL_TYPE_TIME:
1700 case MYSQL_TYPE_DATE:
1701 case MYSQL_TYPE_DATETIME:
1702 case MYSQL_TYPE_TIMESTAMP:
1703
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 return val_real_from_decimal();
1704 14 default:
1705 14 break;
1706 }
1707 const char *end_not_used;
1708 int err_not_used;
1709
1/2
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
 14 String *res = str_op(&str_value);
1710
3/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
 14 return (res ? my_strntod(res->charset(), res->ptr(), res->length(),
1711 &end_not_used, &err_not_used)
1712 14 : 0.0);
1713 }
1714 ✗ default:
1715 ✗ assert(0);
1716 }
1717 return 0.0;
1718 }
1719
1720 127776206 longlong Item_func_numhybrid::val_int() {
1721
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 127776206 times.
 127776206 assert(fixed == 1);
1722
4/5
✓ Branch 0 taken 1154228 times.
✓ Branch 1 taken 126032566 times.
✓ Branch 2 taken 589711 times.
✓ Branch 3 taken 5 times.
✗ Branch 4 not taken.
 127776206 switch (hybrid_type) {
1723 1154228 case DECIMAL_RESULT: {
1724 1154228 my_decimal decimal_value, *val;
1725
3/4
✓ Branch 0 taken 1154228 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 1154218 times.
 1154228 if (!(val = decimal_op(&decimal_value))) return 0; // null is set
1726 longlong result;
1727
1/2
✓ Branch 0 taken 1154218 times.
✗ Branch 1 not taken.
 1154218 my_decimal2int(E_DEC_FATAL_ERROR, val, unsigned_flag, &result);
1728 1154218 return result;
1729 1154228 }
1730 126032566 case INT_RESULT:
1731 126032566 return int_op();
1732 589711 case REAL_RESULT: {
1733 589711 return llrint_with_overflow_check(real_op());
1734 }
1735 5 case STRING_RESULT: {
1736
4/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
 5 switch (data_type()) {
1737 1 case MYSQL_TYPE_DATE:
1738
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 return val_int_from_date();
1739 2 case MYSQL_TYPE_DATETIME:
1740 case MYSQL_TYPE_TIMESTAMP:
1741
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 return val_int_from_datetime();
1742 1 case MYSQL_TYPE_TIME:
1743
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 return val_int_from_time();
1744 1 default:
1745 1 break;
1746 }
1747 int err_not_used;
1748 String *res;
1749
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1 if (!(res = str_op(&str_value))) return 0;
1750
1751 1 const char *end = res->ptr() + res->length();
1752 1 const CHARSET_INFO *cs = res->charset();
1753
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 return (*(cs->cset->strtoll10))(cs, res->ptr(), &end, &err_not_used);
1754 }
1755 ✗ default:
1756 ✗ assert(0);
1757 }
1758 return 0;
1759 }
1760
1761 2583942 my_decimal *Item_func_numhybrid::val_decimal(my_decimal *decimal_value) {
1762 2583942 my_decimal *val = decimal_value;
1763
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2583942 times.
 2583942 assert(fixed == 1);
1764
4/5
✓ Branch 0 taken 2076323 times.
✓ Branch 1 taken 507482 times.
✓ Branch 2 taken 113 times.
✓ Branch 3 taken 24 times.
✗ Branch 4 not taken.
 2583942 switch (hybrid_type) {
1765 2076323 case DECIMAL_RESULT:
1766 2076323 val = decimal_op(decimal_value);
1767 2076323 break;
1768 507482 case INT_RESULT: {
1769 507482 longlong result = int_op();
1770 507482 int2my_decimal(E_DEC_FATAL_ERROR, result, unsigned_flag, decimal_value);
1771 507482 break;
1772 }
1773 113 case REAL_RESULT: {
1774 113 double result = real_op();
1775 113 double2my_decimal(E_DEC_FATAL_ERROR, result, decimal_value);
1776 113 break;
1777 }
1778 24 case STRING_RESULT: {
1779
3/3
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 14 times.
 24 switch (data_type()) {
1780 9 case MYSQL_TYPE_DATE:
1781 case MYSQL_TYPE_DATETIME:
1782 case MYSQL_TYPE_TIMESTAMP:
1783 9 return val_decimal_from_date(decimal_value);
1784 1 case MYSQL_TYPE_TIME:
1785 1 return val_decimal_from_time(decimal_value);
1786 14 default:
1787 14 break;
1788 }
1789 String *res;
1790
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 3 times.
 14 if (!(res = str_op(&str_value))) return nullptr;
1791
1792 3 str2my_decimal(E_DEC_FATAL_ERROR, res->ptr(), res->length(),
1793 res->charset(), decimal_value);
1794 3 break;
1795 }
1796 ✗ case ROW_RESULT:
1797 default:
1798 ✗ assert(0);
1799 }
1800 2583921 return val;
1801 }
1802
1803 224 bool Item_func_numhybrid::get_date(MYSQL_TIME *ltime,
1804 my_time_flags_t fuzzydate) {
1805
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 224 times.
 224 assert(fixed == 1);
1806
4/4
✓ Branch 0 taken 182 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 37 times.
 224 switch (data_type()) {
1807 182 case MYSQL_TYPE_DATE:
1808 case MYSQL_TYPE_DATETIME:
1809 case MYSQL_TYPE_TIMESTAMP:
1810 182 return date_op(ltime, fuzzydate);
1811 4 case MYSQL_TYPE_TIME:
1812 4 return get_date_from_time(ltime);
1813 1 case MYSQL_TYPE_YEAR:
1814 1 return get_date_from_int(ltime, fuzzydate);
1815 37 default:
1816 37 return Item::get_date_from_non_temporal(ltime, fuzzydate);
1817 }
1818 }
1819
1820 44 bool Item_func_numhybrid::get_time(MYSQL_TIME *ltime) {
1821
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44 times.
 44 assert(fixed == 1);
1822
5/5
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 16 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 5 times.
 44 switch (data_type()) {
1823 20 case MYSQL_TYPE_TIME:
1824 20 return time_op(ltime);
1825 2 case MYSQL_TYPE_DATE:
1826 2 return get_time_from_date(ltime);
1827 16 case MYSQL_TYPE_DATETIME:
1828 case MYSQL_TYPE_TIMESTAMP:
1829 16 return get_time_from_datetime(ltime);
1830 1 case MYSQL_TYPE_YEAR:
1831 1 return get_time_from_int(ltime);
1832 5 default:
1833 5 return Item::get_time_from_non_temporal(ltime);
1834 }
1835 }
1836
1837 126 void Item_typecast_signed::print(const THD *thd, String *str,
1838 enum_query_type query_type) const {
1839 126 str->append(STRING_WITH_LEN("cast("));
1840 126 args[0]->print(thd, str, query_type);
1841 126 str->append(STRING_WITH_LEN(" as signed)"));
1842 126 }
1843
1844 4092 bool Item_typecast_signed::resolve_type(THD *thd) {
1845
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 4091 times.
 4092 if (reject_geometry_args(arg_count, args, this)) return true;
1846 4091 return args[0]->propagate_type(thd, MYSQL_TYPE_LONGLONG, false, true);
1847 }
1848
1849 25819 static longlong val_int_from_str(Item *item, bool unsigned_flag,
1850 bool *null_value) {
1851 /*
1852 For a string result, we must first get the string and then convert it
1853 to a longlong
1854 */
1855 25819 StringBuffer<MAX_FIELD_WIDTH> tmp;
1856
1/2
✓ Branch 0 taken 25819 times.
✗ Branch 1 not taken.
 25819 const String *res = item->val_str(&tmp);
1857 25819 *null_value = item->null_value;
1858
2/2
✓ Branch 0 taken 102 times.
✓ Branch 1 taken 25717 times.
 25819 if (*null_value) return 0;
1859
1860 25717 size_t length = res->length();
1861 25717 const char *start = res->ptr();
1862 25717 const char *end = start + length;
1863
1/2
✓ Branch 0 taken 25717 times.
✗ Branch 1 not taken.
 25717 return longlong_from_string_with_check(res->charset(), start, end,
1864 25717 unsigned_flag);
1865 25819 }
1866
1867 26040 longlong Item_typecast_signed::val_int() {
1868 longlong value;
1869
1870
6/6
✓ Branch 0 taken 25724 times.
✓ Branch 1 taken 316 times.
✓ Branch 2 taken 174 times.
✓ Branch 3 taken 25550 times.
✓ Branch 4 taken 490 times.
✓ Branch 5 taken 25550 times.
 26040 if (args[0]->cast_to_int_type() != STRING_RESULT || args[0]->is_temporal()) {
1871 490 value = args[0]->val_int();
1872 490 null_value = args[0]->null_value;
1873 } else {
1874 25550 value = val_int_from_str(args[0], unsigned_flag, &null_value);
1875 }
1876
1877 #ifndef NDEBUG
1878
2/2
✓ Branch 0 taken 89 times.
✓ Branch 1 taken 25951 times.
 26040 if (null_value) {
1879
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 89 times.
 89 assert(is_nullable());
1880
2/2
✓ Branch 0 taken 25799 times.
✓ Branch 1 taken 152 times.
 25951 } else if (value >= 0) {
1881 25799 const int digits = count_digits(static_cast<ulonglong>(value));
1882
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25799 times.
 25799 assert(digits <= decimal_int_part());
1883
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25799 times.
 25799 assert(static_cast<unsigned>(digits) <= max_length);
1884 } else {
1885 const int digits =
1886 152 count_digits(ulonglong{0} - static_cast<ulonglong>(value));
1887
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 152 times.
 152 assert(digits <= decimal_int_part());
1888
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 152 times.
 152 assert(static_cast<unsigned>(digits) + 1 <= max_length);
1889 }
1890 #endif
1891
1892 26040 return value;
1893 }
1894
1895 16390 void Item_typecast_unsigned::print(const THD *thd, String *str,
1896 enum_query_type query_type) const {
1897 16390 str->append(STRING_WITH_LEN("cast("));
1898 16390 args[0]->print(thd, str, query_type);
1899 16390 str->append(STRING_WITH_LEN(" as unsigned)"));
1900 16390 }
1901
1902 1107932 bool Item_typecast_unsigned::resolve_type(THD *thd) {
1903
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1107931 times.
 1107932 if (reject_geometry_args(arg_count, args, this)) return true;
1904 1107931 return args[0]->propagate_type(thd, MYSQL_TYPE_LONGLONG, false, true);
1905 }
1906
1907 3796777 longlong Item_typecast_unsigned::val_int() {
1908 3796777 longlong value = 0;
1909
1910
3/4
✓ Branch 0 taken 3796777 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 518 times.
✓ Branch 3 taken 3796259 times.
 3796777 if (args[0]->cast_to_int_type() == DECIMAL_RESULT) {
1911
1/2
✓ Branch 0 taken 518 times.
✗ Branch 1 not taken.
 518 my_decimal tmp, *dec = args[0]->val_decimal(&tmp);
1912 518 null_value = args[0]->null_value;
1913
2/2
✓ Branch 0 taken 511 times.
✓ Branch 1 taken 7 times.
 518 if (!null_value) {
1914
1/2
✓ Branch 0 taken 511 times.
✗ Branch 1 not taken.
 511 my_decimal2int(E_DEC_FATAL_ERROR, dec, !dec->sign(), &value);
1915 }
1916
7/8
✓ Branch 0 taken 3796259 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 692333 times.
✓ Branch 3 taken 3103926 times.
✓ Branch 4 taken 692064 times.
✓ Branch 5 taken 269 times.
✓ Branch 6 taken 3795990 times.
✓ Branch 7 taken 269 times.
 4489110 } else if (args[0]->cast_to_int_type() != STRING_RESULT ||
1917 692333 args[0]->is_temporal()) {
1918
1/2
✓ Branch 0 taken 3795990 times.
✗ Branch 1 not taken.
 3795990 value = args[0]->val_int();
1919 3795990 null_value = args[0]->null_value;
1920 } else {
1921
1/2
✓ Branch 0 taken 269 times.
✗ Branch 1 not taken.
 269 value = val_int_from_str(args[0], unsigned_flag, &null_value);
1922 }
1923
1924
3/4
✓ Branch 0 taken 593184 times.
✓ Branch 1 taken 3203593 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 593184 times.
 3796777 assert(!null_value || is_nullable());
1925
3/6
✓ Branch 0 taken 3796777 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3796777 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3796777 times.
 3796777 assert(count_digits(static_cast<ulonglong>(value)) <= decimal_int_part());
1926
1927 3796777 return value;
1928 }
1929
1930 489 String *Item_typecast_decimal::val_str(String *str) {
1931
1/2
✓ Branch 0 taken 489 times.
✗ Branch 1 not taken.
 489 my_decimal tmp_buf, *tmp = val_decimal(&tmp_buf);
1932
2/2
✓ Branch 0 taken 62 times.
✓ Branch 1 taken 427 times.
 489 if (null_value) return nullptr;
1933
1/2
✓ Branch 0 taken 427 times.
✗ Branch 1 not taken.
 427 my_decimal2string(E_DEC_FATAL_ERROR, tmp, str);
1934 427 return str;
1935 489 }
1936
1937 6 double Item_typecast_decimal::val_real() {
1938
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 my_decimal tmp_buf, *tmp = val_decimal(&tmp_buf);
1939 double res;
1940
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4 times.
 6 if (null_value) return 0.0;
1941
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 my_decimal2double(E_DEC_FATAL_ERROR, tmp, &res);
1942 4 return res;
1943 6 }
1944
1945 14 longlong Item_typecast_decimal::val_int() {
1946
1/2
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
 14 my_decimal tmp_buf, *tmp = val_decimal(&tmp_buf);
1947 longlong res;
1948
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 12 times.
 14 if (null_value) return 0;
1949
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
 12 my_decimal2int(E_DEC_FATAL_ERROR, tmp, unsigned_flag, &res);
1950 12 return res;
1951 14 }
1952
1953 11229 my_decimal *Item_typecast_decimal::val_decimal(my_decimal *dec) {
1954
1/2
✓ Branch 0 taken 11229 times.
✗ Branch 1 not taken.
 11229 my_decimal tmp_buf, *tmp = args[0]->val_decimal(&tmp_buf);
1955 bool sign;
1956 uint precision;
1957
1958
2/2
✓ Branch 0 taken 265 times.
✓ Branch 1 taken 10964 times.
 11229 if ((null_value = args[0]->null_value)) return nullptr;
1959
1/2
✓ Branch 0 taken 10964 times.
✗ Branch 1 not taken.
 10964 my_decimal_round(E_DEC_FATAL_ERROR, tmp, decimals, false, dec);
1960 10964 sign = dec->sign();
1961
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10964 times.
 10964 if (unsigned_flag) {
1962 ✗ if (sign) {
1963 ✗ my_decimal_set_zero(dec);
1964 ✗ goto err;
1965 }
1966 }
1967 precision =
1968 10964 my_decimal_length_to_precision(max_length, decimals, unsigned_flag);
1969
3/4
✓ Branch 0 taken 10964 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 10931 times.
 10964 if (precision - decimals < (uint)my_decimal_intg(dec)) {
1970
1/2
✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
 33 max_my_decimal(dec, precision, decimals);
1971 33 dec->sign(sign);
1972 33 goto err;
1973 }
1974 10931 return dec;
1975
1976 33 err:
1977 33 push_warning_printf(
1978
2/4
✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
 33 current_thd, Sql_condition::SL_WARNING, ER_WARN_DATA_OUT_OF_RANGE,
1979
2/4
✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
 33 ER_THD(current_thd, ER_WARN_DATA_OUT_OF_RANGE), item_name.ptr(), 1L);
1980 33 return dec;
1981 11229 }
1982
1983 113 void Item_typecast_decimal::print(const THD *thd, String *str,
1984 enum_query_type query_type) const {
1985 uint precision =
1986 113 my_decimal_length_to_precision(max_length, decimals, unsigned_flag);
1987 113 str->append(STRING_WITH_LEN("cast("));
1988 113 args[0]->print(thd, str, query_type);
1989 113 str->append(STRING_WITH_LEN(" as decimal("));
1990 113 str->append_ulonglong(precision);
1991 113 str->append(',');
1992 113 str->append_ulonglong(decimals);
1993 113 str->append(')');
1994 113 str->append(')');
1995 113 }
1996
1997 1 String *Item_typecast_real::val_str(String *str) {
1998 1 double res = val_real();
1999
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (null_value) return nullptr;
2000
2001 1 str->set_real(res, decimals, collation.collation);
2002 1 return str;
2003 }
2004
2005 23460 double Item_typecast_real::val_real() {
2006 23460 double res = args[0]->val_real();
2007 23460 null_value = args[0]->null_value;
2008
2/2
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 23438 times.
 23460 if (null_value) return 0.0;
2009
4/4
✓ Branch 0 taken 235 times.
✓ Branch 1 taken 23203 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 23436 times.
 23673 if (data_type() == MYSQL_TYPE_FLOAT &&
2010
2/2
✓ Branch 0 taken 234 times.
✓ Branch 1 taken 1 times.
 235 ((res > std::numeric_limits<float>::max()) ||
2011
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 233 times.
 234 res < std::numeric_limits<float>::lowest()))
2012 2 return raise_float_overflow();
2013 23436 return check_float_overflow(res);
2014 }
2015
2016 1 longlong Item_func::val_int_from_real() {
2017 1 double res = val_real();
2018
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (null_value) return 0;
2019
2020
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (unsigned_flag) {
2021 ✗ if (res < 0 || res >= ULLONG_MAX_DOUBLE) {
2022 ✗ return raise_integer_overflow();
2023 } else
2024 ✗ return (longlong)double2ulonglong(res);
2025 } else {
2026
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 if (res <= LLONG_MIN || res > LLONG_MAX_DOUBLE) {
2027 1 return raise_integer_overflow();
2028 } else
2029 ✗ return (longlong)res;
2030 }
2031 }
2032
2033 1 bool Item_typecast_real::get_date(MYSQL_TIME *ltime,
2034 my_time_flags_t fuzzydate) {
2035 1 return my_double_to_datetime_with_warn(val_real(), ltime, fuzzydate);
2036 }
2037
2038 1 bool Item_typecast_real::get_time(MYSQL_TIME *ltime) {
2039 1 return my_double_to_time_with_warn(val_real(), ltime);
2040 }
2041
2042 2 my_decimal *Item_typecast_real::val_decimal(my_decimal *decimal_value) {
2043 2 double result = val_real();
2044
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (null_value) return nullptr;
2045 2 double2my_decimal(E_DEC_FATAL_ERROR, result, decimal_value);
2046
2047 2 return decimal_value;
2048 }
2049
2050 399 void Item_typecast_real::print(const THD *thd, String *str,
2051 enum_query_type query_type) const {
2052 399 str->append(STRING_WITH_LEN("cast("));
2053 399 args[0]->print(thd, str, query_type);
2054 399 str->append(STRING_WITH_LEN(" as "));
2055
3/4
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 393 times.
✓ Branch 2 taken 399 times.
✗ Branch 3 not taken.
 399 str->append((data_type() == MYSQL_TYPE_FLOAT) ? "float)" : "double)");
2056 399 }
2057
2058 1254897 double Item_func_plus::real_op() {
2059 1254897 double val1 = args[0]->val_real();
2060
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1254900 times.
 1254900 if (current_thd->is_error()) return error_real();
2061 1254900 double val2 = args[1]->val_real();
2062
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1254896 times.
 1254899 if (current_thd->is_error()) return error_real();
2063
2064
6/6
✓ Branch 0 taken 1254864 times.
✓ Branch 1 taken 32 times.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 1254834 times.
✓ Branch 4 taken 62 times.
✓ Branch 5 taken 1254834 times.
 1254896 if ((null_value = args[0]->null_value || args[1]->null_value)) return 0.0;
2065 1254834 double value = val1 + val2;
2066 1254834 return check_float_overflow(value);
2067 }
2068
2069 117541738 longlong Item_func_plus::int_op() {
2070 117541738 longlong val0 = args[0]->val_int();
2071
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 117542134 times.
 117542071 if (current_thd->is_error()) return error_int();
2072 117542134 longlong val1 = args[1]->val_int();
2073
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 117542127 times.
 117541914 if (current_thd->is_error()) return error_int();
2074 117542127 longlong res = static_cast<unsigned long long>(val0) +
2075 117542127 static_cast<unsigned long long>(val1);
2076 117542127 bool res_unsigned = false;
2077
2078
6/6
✓ Branch 0 taken 117535064 times.
✓ Branch 1 taken 7063 times.
✓ Branch 2 taken 544 times.
✓ Branch 3 taken 117534520 times.
✓ Branch 4 taken 7607 times.
✓ Branch 5 taken 117534520 times.
 117542127 if ((null_value = args[0]->null_value || args[1]->null_value)) return 0;
2079
2080 /*
2081 First check whether the result can be represented as a
2082 (bool unsigned_flag, longlong value) pair, then check if it is compatible
2083 with this Item's unsigned_flag by calling check_integer_overflow().
2084 */
2085
2/2
✓ Branch 0 taken 466793 times.
✓ Branch 1 taken 117067727 times.
 117534520 if (args[0]->unsigned_flag) {
2086
4/4
✓ Branch 0 taken 100550 times.
✓ Branch 1 taken 366243 times.
✓ Branch 2 taken 100549 times.
✓ Branch 3 taken 1 times.
 466793 if (args[1]->unsigned_flag || val1 >= 0) {
2087
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 466765 times.
 466792 if (test_if_sum_overflows_ull((ulonglong)val0, (ulonglong)val1)) goto err;
2088 466765 res_unsigned = true;
2089 } else {
2090 /* val1 is negative */
2091
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if ((ulonglong)val0 > (ulonglong)LLONG_MAX) res_unsigned = true;
2092 }
2093 } else {
2094
2/2
✓ Branch 0 taken 25315 times.
✓ Branch 1 taken 117042412 times.
 117067727 if (args[1]->unsigned_flag) {
2095
2/2
✓ Branch 0 taken 25313 times.
✓ Branch 1 taken 2 times.
 25315 if (val0 >= 0) {
2096
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 25312 times.
 25313 if (test_if_sum_overflows_ull((ulonglong)val0, (ulonglong)val1))
2097 1 goto err;
2098 25312 res_unsigned = true;
2099 } else {
2100
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if ((ulonglong)val1 > (ulonglong)LLONG_MAX) res_unsigned = true;
2101 }
2102 } else {
2103
4/4
✓ Branch 0 taken 117037774 times.
✓ Branch 1 taken 4638 times.
✓ Branch 2 taken 117032207 times.
✓ Branch 3 taken 5567 times.
 117042412 if (val0 >= 0 && val1 >= 0)
2104 117032207 res_unsigned = true;
2105
6/6
✓ Branch 0 taken 4347 times.
✓ Branch 1 taken 5858 times.
✓ Branch 2 taken 1683 times.
✓ Branch 3 taken 2664 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 1682 times.
 10205 else if (val0 < 0 && val1 < 0 && res >= 0)
2106 1 goto err;
2107 }
2108 }
2109 117534491 return check_integer_overflow(res, res_unsigned);
2110
2111 29 err:
2112 29 return raise_integer_overflow();
2113 }
2114
2115 /**
2116 Calculate plus of two decimals.
2117
2118 @param decimal_value Buffer that can be used to store result
2119
2120 @return Value of operation as a decimal
2121 @retval
2122 0 Value was NULL; In this case null_value is set
2123 */
2124
2125 225500 my_decimal *Item_func_plus::decimal_op(my_decimal *decimal_value) {
2126 225500 my_decimal value1, *val1;
2127 225500 my_decimal value2, *val2;
2128
1/2
✓ Branch 0 taken 225500 times.
✗ Branch 1 not taken.
 225500 val1 = args[0]->val_decimal(&value1);
2129
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 225492 times.
 225500 if ((null_value = args[0]->null_value)) return nullptr;
2130
1/2
✓ Branch 0 taken 225492 times.
✗ Branch 1 not taken.
 225492 val2 = args[1]->val_decimal(&value2);
2131
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 225471 times.
 225492 if ((null_value = args[1]->null_value)) return nullptr;
2132
2133
2/4
✓ Branch 0 taken 225471 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 225471 times.
✗ Branch 3 not taken.
 225471 if (check_decimal_overflow(my_decimal_add(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
2134
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 225471 times.
 225471 decimal_value, val1, val2)) > 3) {
2135 ✗ return error_decimal(decimal_value);
2136 }
2137 225471 return decimal_value;
2138 225500 }
2139
2140 /**
2141 Set precision of results for additive operations (+ and -)
2142 */
2143 2252788 void Item_func_additive_op::result_precision() {
2144 2252788 decimals = max(args[0]->decimals, args[1]->decimals);
2145
1/2
✓ Branch 0 taken 2252790 times.
✗ Branch 1 not taken.
 2252791 int arg1_int = args[0]->decimal_precision() - args[0]->decimals;
2146
1/2
✓ Branch 0 taken 2252791 times.
✗ Branch 1 not taken.
 2252790 int arg2_int = args[1]->decimal_precision() - args[1]->decimals;
2147 2252791 int precision = max(arg1_int, arg2_int) + 1 + decimals;
2148
2149 /* Integer operations keep unsigned_flag if one of arguments is unsigned */
2150
3/4
✓ Branch 0 taken 2252793 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2213777 times.
✓ Branch 3 taken 39016 times.
 2252792 if (result_type() == INT_RESULT)
2151 2213777 unsigned_flag = args[0]->unsigned_flag | args[1]->unsigned_flag;
2152 else
2153 39016 unsigned_flag = args[0]->unsigned_flag & args[1]->unsigned_flag;
2154 4505594 max_length = my_decimal_precision_to_length_no_truncation(precision, decimals,
2155 2252793 unsigned_flag);
2156 2252801 }
2157
2158 /**
2159 The following function is here to allow the user to force
2160 subtraction of UNSIGNED BIGINT/DECIMAL to return negative values.
2161 */
2162
2163 943576 bool Item_func_minus::resolve_type(THD *thd) {
2164
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 943574 times.
 943576 if (Item_num_op::resolve_type(thd)) return true;
2165
4/4
✓ Branch 0 taken 28100 times.
✓ Branch 1 taken 915474 times.
✓ Branch 2 taken 29 times.
✓ Branch 3 taken 28071 times.
 943574 if (unsigned_flag && (thd->variables.sql_mode & MODE_NO_UNSIGNED_SUBTRACTION))
2166 29 unsigned_flag = false;
2167 943574 return false;
2168 }
2169
2170 5045 double Item_func_minus::real_op() {
2171 5045 double val1 = args[0]->val_real();
2172
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5045 times.
 5045 if (current_thd->is_error()) return error_real();
2173 5045 double val2 = args[1]->val_real();
2174
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5045 times.
 5045 if (current_thd->is_error()) return error_real();
2175
2176
6/6
✓ Branch 0 taken 5044 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 5043 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 5043 times.
 5045 if ((null_value = args[0]->null_value || args[1]->null_value)) return 0.0;
2177 5043 double value = val1 - val2;
2178 5043 return check_float_overflow(value);
2179 }
2180
2181 2520878 longlong Item_func_minus::int_op() {
2182 2520878 longlong val0 = args[0]->val_int();
2183
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2520878 times.
 2520878 if (current_thd->is_error()) return error_int();
2184 2520878 longlong val1 = args[1]->val_int();
2185
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2520876 times.
 2520878 if (current_thd->is_error()) return error_int();
2186 2520876 longlong res = static_cast<unsigned long long>(val0) -
2187 2520876 static_cast<unsigned long long>(val1);
2188 2520876 bool res_unsigned = false;
2189
2190
6/6
✓ Branch 0 taken 2520819 times.
✓ Branch 1 taken 57 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 2520810 times.
✓ Branch 4 taken 66 times.
✓ Branch 5 taken 2520810 times.
 2520876 if ((null_value = args[0]->null_value || args[1]->null_value)) return 0;
2191
2192 /*
2193 First check whether the result can be represented as a
2194 (bool unsigned_flag, longlong value) pair, then check if it is compatible
2195 with this Item's unsigned_flag by calling check_integer_overflow().
2196 */
2197
2/2
✓ Branch 0 taken 630602 times.
✓ Branch 1 taken 1890208 times.
 2520810 if (args[0]->unsigned_flag) {
2198
2/2
✓ Branch 0 taken 1285 times.
✓ Branch 1 taken 629317 times.
 630602 if (args[1]->unsigned_flag) {
2199
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1281 times.
 1285 if ((ulonglong)val0 < (ulonglong)val1) {
2200
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
 4 if (res >= 0) goto err;
2201 } else
2202 1281 res_unsigned = true;
2203 } else {
2204
2/2
✓ Branch 0 taken 629315 times.
✓ Branch 1 taken 2 times.
 629317 if (val1 >= 0) {
2205
2/2
✓ Branch 0 taken 609146 times.
✓ Branch 1 taken 20169 times.
 629315 if ((ulonglong)val0 > (ulonglong)val1) res_unsigned = true;
2206 } else {
2207
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if (test_if_sum_overflows_ull((ulonglong)val0, (ulonglong)-val1))
2208 1 goto err;
2209 1 res_unsigned = true;
2210 }
2211 }
2212 } else {
2213
2/2
✓ Branch 0 taken 38 times.
✓ Branch 1 taken 1890170 times.
 1890208 if (args[1]->unsigned_flag) {
2214
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 37 times.
 38 if ((ulonglong)(val0 - LLONG_MIN) < (ulonglong)val1) goto err;
2215 } else {
2216
4/4
✓ Branch 0 taken 1884912 times.
✓ Branch 1 taken 5258 times.
✓ Branch 2 taken 37 times.
✓ Branch 3 taken 1884875 times.
 1890170 if (val0 >= 0 && val1 < 0)
2217 37 res_unsigned = true;
2218
5/6
✓ Branch 0 taken 5258 times.
✓ Branch 1 taken 1884875 times.
✓ Branch 2 taken 5258 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 5257 times.
 1890133 else if (val0 < 0 && val1 > 0 && res >= 0)
2219 1 goto err;
2220 }
2221 }
2222 2520806 return check_integer_overflow(res, res_unsigned);
2223
2224 4 err:
2225 4 return raise_integer_overflow();
2226 }
2227
2228 /**
2229 See Item_func_plus::decimal_op for comments.
2230 */
2231
2232 203942 my_decimal *Item_func_minus::decimal_op(my_decimal *decimal_value) {
2233 203942 my_decimal value1, *val1;
2234 203942 my_decimal value2, *val2;
2235
2236
1/2
✓ Branch 0 taken 203942 times.
✗ Branch 1 not taken.
 203942 val1 = args[0]->val_decimal(&value1);
2237
2/2
✓ Branch 0 taken 158 times.
✓ Branch 1 taken 203784 times.
 203942 if ((null_value = args[0]->null_value)) return nullptr;
2238
2239
1/2
✓ Branch 0 taken 203784 times.
✗ Branch 1 not taken.
 203784 val2 = args[1]->val_decimal(&value2);
2240
2/2
✓ Branch 0 taken 204 times.
✓ Branch 1 taken 203580 times.
 203784 if ((null_value = args[1]->null_value)) return nullptr;
2241
2242
2/4
✓ Branch 0 taken 203580 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 203580 times.
✗ Branch 3 not taken.
 203580 if (check_decimal_overflow(my_decimal_sub(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
2243
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 203580 times.
 203580 decimal_value, val1, val2)) > 3) {
2244 ✗ return error_decimal(decimal_value);
2245 }
2246 /*
2247 Allow sign mismatch only if sql_mode includes MODE_NO_UNSIGNED_SUBTRACTION
2248 See Item_func_minus::resolve_type().
2249 */
2250
6/6
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 203575 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 203577 times.
 203580 if (unsigned_flag && decimal_value->sign()) {
2251
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 raise_decimal_overflow();
2252 3 return error_decimal(decimal_value);
2253 }
2254 203577 return decimal_value;
2255 203942 }
2256
2257 1681209 double Item_func_mul::real_op() {
2258
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1681209 times.
 1681209 assert(fixed == 1);
2259 1681209 double val1 = args[0]->val_real();
2260
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1681212 times.
 1681210 if (current_thd->is_error()) return error_real();
2261 1681212 double val2 = args[1]->val_real();
2262
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1681212 times.
 1681212 if (current_thd->is_error()) return error_real();
2263
2264
5/6
✓ Branch 0 taken 1681210 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1681210 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 1681210 times.
 1681212 if ((null_value = args[0]->null_value || args[1]->null_value)) return 0.0;
2265 1681210 double value = val1 * val2;
2266 1681210 return check_float_overflow(value);
2267 }
2268
2269 1343089 longlong Item_func_mul::int_op() {
2270
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1343089 times.
 1343089 assert(fixed == 1);
2271 1343089 longlong a = args[0]->val_int();
2272
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1343104 times.
 1343105 if (current_thd->is_error()) return error_int();
2273 1343104 longlong b = args[1]->val_int();
2274
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1343102 times.
 1343103 if (current_thd->is_error()) return error_int();
2275 longlong res;
2276 ulonglong res0, res1;
2277
2278
6/6
✓ Branch 0 taken 1343002 times.
✓ Branch 1 taken 100 times.
✓ Branch 2 taken 73 times.
✓ Branch 3 taken 1342929 times.
✓ Branch 4 taken 173 times.
✓ Branch 5 taken 1342929 times.
 1343102 if ((null_value = args[0]->null_value || args[1]->null_value)) return 0;
2279
2280
4/4
✓ Branch 0 taken 1189988 times.
✓ Branch 1 taken 152941 times.
✓ Branch 2 taken 15084 times.
✓ Branch 3 taken 1174904 times.
 1342929 if (a == 0 || b == 0) return 0;
2281
2282 /*
2283 First check whether the result can be represented as a
2284 (bool unsigned_flag, longlong value) pair, then check if it is compatible
2285 with this Item's unsigned_flag by calling check_integer_overflow().
2286
2287 Let a = a1 * 2^32 + a0 and b = b1 * 2^32 + b0. Then
2288 a * b = (a1 * 2^32 + a0) * (b1 * 2^32 + b0) = a1 * b1 * 2^64 +
2289 + (a1 * b0 + a0 * b1) * 2^32 + a0 * b0;
2290 We can determine if the above sum overflows the ulonglong range by
2291 sequentially checking the following conditions:
2292 1. If both a1 and b1 are non-zero.
2293 2. Otherwise, if (a1 * b0 + a0 * b1) is greater than ULONG_MAX.
2294 3. Otherwise, if (a1 * b0 + a0 * b1) * 2^32 + a0 * b0 is greater than
2295 ULLONG_MAX.
2296
2297 Since we also have to take the unsigned_flag for a and b into account,
2298 it is easier to first work with absolute values and set the
2299 correct sign later.
2300
2301 We handle INT_MIN64 == -9223372036854775808 specially first,
2302 to avoid UBSAN warnings.
2303 */
2304
4/4
✓ Branch 0 taken 874551 times.
✓ Branch 1 taken 300353 times.
✓ Branch 2 taken 390 times.
✓ Branch 3 taken 874161 times.
 1174904 const bool a_negative = (!args[0]->unsigned_flag && a < 0);
2305
4/4
✓ Branch 0 taken 1170280 times.
✓ Branch 1 taken 4624 times.
✓ Branch 2 taken 2162 times.
✓ Branch 3 taken 1168118 times.
 1174904 const bool b_negative = (!args[1]->unsigned_flag && b < 0);
2306
2307 1174904 const bool res_unsigned = (a_negative == b_negative);
2308
2309
4/4
✓ Branch 0 taken 390 times.
✓ Branch 1 taken 1174514 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 386 times.
 1174904 if (a_negative && a == INT_MIN64) {
2310
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
 4 if (b == 1) return check_integer_overflow(a, res_unsigned);
2311 3 return raise_integer_overflow();
2312 }
2313
2314
4/4
✓ Branch 0 taken 2161 times.
✓ Branch 1 taken 1172739 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2157 times.
 1174900 if (b_negative && b == INT_MIN64) {
2315
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
 4 if (a == 1) return check_integer_overflow(b, res_unsigned);
2316 3 return raise_integer_overflow();
2317 }
2318
2319
2/2
✓ Branch 0 taken 385 times.
✓ Branch 1 taken 1174511 times.
 1174896 if (a_negative) {
2320 385 a = -a;
2321 }
2322
2/2
✓ Branch 0 taken 2157 times.
✓ Branch 1 taken 1172739 times.
 1174896 if (b_negative) {
2323 2157 b = -b;
2324 }
2325
2326 1174896 ulong a0 = 0xFFFFFFFFUL & a;
2327 1174896 ulong a1 = ((ulonglong)a) >> 32;
2328 1174896 ulong b0 = 0xFFFFFFFFUL & b;
2329 1174896 ulong b1 = ((ulonglong)b) >> 32;
2330
2331
4/4
✓ Branch 0 taken 157 times.
✓ Branch 1 taken 1174739 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 156 times.
 1174896 if (a1 && b1) goto err;
2332
2333 1174895 res1 = (ulonglong)a1 * b0 + (ulonglong)a0 * b1;
2334
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 1174888 times.
 1174895 if (res1 > 0xFFFFFFFFUL) goto err;
2335
2336 1174888 res1 = res1 << 32;
2337 1174888 res0 = (ulonglong)a0 * b0;
2338
2339
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1174875 times.
 1174888 if (test_if_sum_overflows_ull(res1, res0)) goto err;
2340 1174875 res = res1 + res0;
2341
2342
2/2
✓ Branch 0 taken 2366 times.
✓ Branch 1 taken 1172509 times.
 1174875 if (a_negative != b_negative) {
2343
2/2
✓ Branch 0 taken 85 times.
✓ Branch 1 taken 2281 times.
 2366 if ((ulonglong)res > (ulonglong)LLONG_MAX) goto err;
2344 2281 res = -res;
2345 }
2346
2347 1174790 return check_integer_overflow(res, res_unsigned);
2348
2349 94 err:
2350 94 return raise_integer_overflow();
2351 }
2352
2353 /** See Item_func_plus::decimal_op for comments. */
2354
2355 381022 my_decimal *Item_func_mul::decimal_op(my_decimal *decimal_value) {
2356 381022 my_decimal value1, *val1;
2357 381022 my_decimal value2, *val2;
2358
1/2
✓ Branch 0 taken 381022 times.
✗ Branch 1 not taken.
 381022 val1 = args[0]->val_decimal(&value1);
2359
2/2
✓ Branch 0 taken 204 times.
✓ Branch 1 taken 380818 times.
 381022 if ((null_value = args[0]->null_value)) return nullptr;
2360
1/2
✓ Branch 0 taken 380818 times.
✗ Branch 1 not taken.
 380818 val2 = args[1]->val_decimal(&value2);
2361
2/2
✓ Branch 0 taken 123 times.
✓ Branch 1 taken 380695 times.
 380818 if ((null_value = args[1]->null_value)) return nullptr;
2362
2363
2/4
✓ Branch 0 taken 380695 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 380695 times.
✗ Branch 3 not taken.
 380695 if (check_decimal_overflow(my_decimal_mul(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
2364
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 380695 times.
 380695 decimal_value, val1, val2)) > 3) {
2365 ✗ return error_decimal(decimal_value);
2366 }
2367 380695 return decimal_value;
2368 381022 }
2369
2370 225778 void Item_func_mul::result_precision() {
2371 /* Integer operations keep unsigned_flag if one of arguments is unsigned */
2372
2/2
✓ Branch 0 taken 207713 times.
✓ Branch 1 taken 18065 times.
 225778 if (result_type() == INT_RESULT)
2373 207713 unsigned_flag = args[0]->unsigned_flag | args[1]->unsigned_flag;
2374 else
2375 18065 unsigned_flag = args[0]->unsigned_flag & args[1]->unsigned_flag;
2376 225778 decimals = min(args[0]->decimals + args[1]->decimals, DECIMAL_MAX_SCALE);
2377
2/4
✓ Branch 0 taken 225778 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 225778 times.
✗ Branch 3 not taken.
 225778 uint est_prec = args[0]->decimal_precision() + args[1]->decimal_precision();
2378 225778 uint precision = min<uint>(est_prec, DECIMAL_MAX_PRECISION);
2379 451556 max_length = my_decimal_precision_to_length_no_truncation(precision, decimals,
2380 225778 unsigned_flag);
2381 225778 }
2382
2383 6282 double Item_func_div_base::real_op() {
2384
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6282 times.
 6282 assert(fixed);
2385 6282 double val1 = args[0]->val_real();
2386
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6282 times.
 6282 if (current_thd->is_error()) return error_real();
2387 6282 double val2 = args[1]->val_real();
2388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6282 times.
 6282 if (current_thd->is_error()) return error_real();
2389
2390
5/6
✓ Branch 0 taken 6282 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 6269 times.
✓ Branch 4 taken 13 times.
✓ Branch 5 taken 6269 times.
 6282 if ((null_value = args[0]->null_value || args[1]->null_value)) return 0.0;
2391
2/2
✓ Branch 0 taken 5043 times.
✓ Branch 1 taken 1226 times.
 6269 if (val2 == 0.0) {
2392 5043 signal_divide_by_null();
2393 5043 return 0.0;
2394 }
2395 1226 return check_float_overflow(val1 / val2);
2396 }
2397
2398 1240916 my_decimal *Item_func_div_base::decimal_op(my_decimal *decimal_value) {
2399 1240916 my_decimal value1, *val1;
2400 1240916 my_decimal value2, *val2;
2401 int err;
2402
2403
1/2
✓ Branch 0 taken 1240916 times.
✗ Branch 1 not taken.
 1240916 val1 = args[0]->val_decimal(&value1);
2404
2/2
✓ Branch 0 taken 6327 times.
✓ Branch 1 taken 1234589 times.
 1240916 if ((null_value = args[0]->null_value)) return nullptr;
2405
1/2
✓ Branch 0 taken 1234589 times.
✗ Branch 1 not taken.
 1234589 val2 = args[1]->val_decimal(&value2);
2406
2/2
✓ Branch 0 taken 940 times.
✓ Branch 1 taken 1233649 times.
 1234589 if ((null_value = args[1]->null_value)) return nullptr;
2407
2408
1/2
✓ Branch 0 taken 1233649 times.
✗ Branch 1 not taken.
 1233649 if ((err = check_decimal_overflow(
2409 my_decimal_div(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW & ~E_DEC_DIV_ZERO,
2410
3/4
✓ Branch 0 taken 1233649 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5744 times.
✓ Branch 3 taken 1227905 times.
 2467298 decimal_value, val1, val2, m_prec_increment))) > 3) {
2411
2/4
✓ Branch 0 taken 5744 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5744 times.
✗ Branch 3 not taken.
 5744 if (err == E_DEC_DIV_ZERO) signal_divide_by_null();
2412 5744 return error_decimal(decimal_value);
2413 }
2414 1227905 return decimal_value;
2415 1240916 }
2416
2417 1121944 void Item_func_div::result_precision() {
2418 1121944 uint precision = min<uint>(
2419 1121944 args[0]->decimal_precision() + args[1]->decimals + m_prec_increment,
2420
1/2
✓ Branch 0 taken 1121944 times.
✗ Branch 1 not taken.
 1121944 DECIMAL_MAX_PRECISION);
2421
2422
3/4
✓ Branch 0 taken 648132 times.
✓ Branch 1 taken 473812 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 648132 times.
 1121944 if (result_type() == DECIMAL_RESULT) assert(precision > 0);
2423
2424 /* Integer operations keep unsigned_flag if one of arguments is unsigned */
2425
2/2
✓ Branch 0 taken 473812 times.
✓ Branch 1 taken 648132 times.
 1121944 if (result_type() == INT_RESULT)
2426 473812 unsigned_flag = args[0]->unsigned_flag | args[1]->unsigned_flag;
2427 else
2428 648132 unsigned_flag = args[0]->unsigned_flag & args[1]->unsigned_flag;
2429 1121944 decimals = min<uint>(args[0]->decimals + m_prec_increment, DECIMAL_MAX_SCALE);
2430 2243888 max_length = my_decimal_precision_to_length_no_truncation(precision, decimals,
2431 1121944 unsigned_flag);
2432 1121944 }
2433
2434 849629 void Item_func_div_int::result_precision() {
2435
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 849629 times.
 849629 assert(result_type() == INT_RESULT);
2436
2437 // Integer operations keep unsigned_flag if one of arguments is unsigned
2438 849629 unsigned_flag = args[0]->unsigned_flag | args[1]->unsigned_flag;
2439
2440 849629 uint arg0_decimals = args[0]->decimals;
2441
2/2
✓ Branch 0 taken 34 times.
✓ Branch 1 taken 849595 times.
 849629 if (arg0_decimals == DECIMAL_NOT_SPECIFIED) arg0_decimals = 0;
2442 849629 uint arg1_decimals = args[1]->decimals;
2443
2/2
✓ Branch 0 taken 39 times.
✓ Branch 1 taken 849590 times.
 849629 if (arg1_decimals == DECIMAL_NOT_SPECIFIED)
2444 39 arg1_decimals = args[1]->decimal_precision();
2445
2446 uint precision =
2447 849629 min<uint>(args[0]->decimal_precision() - arg0_decimals + arg1_decimals,
2448
1/2
✓ Branch 0 taken 849629 times.
✗ Branch 1 not taken.
 849629 MY_INT64_NUM_DECIMAL_DIGITS);
2449
2450 849629 max_length =
2451 849629 my_decimal_precision_to_length_no_truncation(precision, 0, unsigned_flag);
2452 849629 }
2453
2454 566296 bool Item_func_div::resolve_type(THD *thd) {
2455
1/2
✓ Branch 0 taken 566296 times.
✗ Branch 1 not taken.
 566296 DBUG_TRACE;
2456 566296 m_prec_increment = thd->variables.div_precincrement;
2457
3/4
✓ Branch 0 taken 566296 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 566293 times.
 566296 if (Item_num_op::resolve_type(thd)) return true;
2458
2459
3/4
✓ Branch 0 taken 5321 times.
✓ Branch 1 taken 473812 times.
✓ Branch 2 taken 87160 times.
✗ Branch 3 not taken.
 566293 switch (hybrid_type) {
2460 5321 case REAL_RESULT: {
2461 5321 decimals = max(args[0]->decimals, args[1]->decimals) + m_prec_increment;
2462 5321 decimals = min(decimals, uint8(DECIMAL_NOT_SPECIFIED));
2463 5321 uint tmp = float_length(decimals);
2464
2/2
✓ Branch 0 taken 5269 times.
✓ Branch 1 taken 52 times.
 5321 if (decimals == DECIMAL_NOT_SPECIFIED)
2465 5269 max_length = tmp;
2466 else {
2467 52 max_length = args[0]->max_length - args[0]->decimals + decimals;
2468 52 max_length = min(max_length, tmp);
2469 }
2470 5321 break;
2471 }
2472 473812 case INT_RESULT:
2473 473812 set_data_type(MYSQL_TYPE_NEWDECIMAL);
2474 473812 hybrid_type = DECIMAL_RESULT;
2475
3/8
✓ Branch 0 taken 473812 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 473812 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 473812 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 473812 DBUG_PRINT("info", ("Type changed: DECIMAL_RESULT"));
2476
1/2
✓ Branch 0 taken 473812 times.
✗ Branch 1 not taken.
 473812 result_precision();
2477 473812 break;
2478 87160 case DECIMAL_RESULT:
2479
1/2
✓ Branch 0 taken 87160 times.
✗ Branch 1 not taken.
 87160 result_precision();
2480 87160 break;
2481 ✗ default:
2482 ✗ assert(0);
2483 }
2484 566293 set_nullable(true); // division by zero
2485 566293 return false;
2486 566296 }
2487
2488 955644 longlong Item_func_div_base::int_op() {
2489
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 955644 times.
 955644 assert(fixed);
2490
2491 /*
2492 Perform division using DECIMAL math if either of the operands has a
2493 non-integer type
2494 */
2495
4/4
✓ Branch 0 taken 955467 times.
✓ Branch 1 taken 177 times.
✓ Branch 2 taken 192 times.
✓ Branch 3 taken 955452 times.
 1911111 if (args[0]->result_type() != INT_RESULT ||
2496
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 955452 times.
 955467 args[1]->result_type() != INT_RESULT) {
2497 192 my_decimal tmp;
2498
1/2
✓ Branch 0 taken 192 times.
✗ Branch 1 not taken.
 192 my_decimal *val0p = args[0]->val_decimal(&tmp);
2499
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 190 times.
 192 if ((null_value = args[0]->null_value)) return 0;
2500
1/2
✓ Branch 0 taken 190 times.
✗ Branch 1 not taken.
 190 my_decimal val0 = *val0p;
2501
2502
1/2
✓ Branch 0 taken 190 times.
✗ Branch 1 not taken.
 190 my_decimal *val1p = args[1]->val_decimal(&tmp);
2503
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 183 times.
 190 if ((null_value = args[1]->null_value)) return 0;
2504
1/2
✓ Branch 0 taken 183 times.
✗ Branch 1 not taken.
 183 my_decimal val1 = *val1p;
2505
2506 int err;
2507
1/2
✓ Branch 0 taken 183 times.
✗ Branch 1 not taken.
 183 if ((err = my_decimal_div(E_DEC_FATAL_ERROR & ~E_DEC_DIV_ZERO, &tmp, &val0,
2508
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 180 times.
 183 &val1, 0)) > 3) {
2509
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 if (err == E_DEC_DIV_ZERO) signal_divide_by_null();
2510 3 return 0;
2511 }
2512
2513 180 my_decimal truncated;
2514 180 const bool do_truncate = true;
2515
2/4
✓ Branch 0 taken 180 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 180 times.
 180 if (my_decimal_round(E_DEC_FATAL_ERROR, &tmp, 0, do_truncate, &truncated))
2516 ✗ assert(false);
2517
2518 longlong res;
2519
3/4
✓ Branch 0 taken 180 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 174 times.
 180 if (my_decimal2int(E_DEC_FATAL_ERROR, &truncated, unsigned_flag, &res) &
2520 E_DEC_OVERFLOW)
2521
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 raise_integer_overflow();
2522 180 return res;
2523 192 }
2524
2525 955452 longlong val0 = args[0]->val_int();
2526 955452 longlong val1 = args[1]->val_int();
2527 bool val0_negative, val1_negative, res_negative;
2528 ulonglong uval0, uval1, res;
2529
6/6
✓ Branch 0 taken 955361 times.
✓ Branch 1 taken 91 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 955360 times.
✓ Branch 4 taken 92 times.
✓ Branch 5 taken 955360 times.
 955452 if ((null_value = (args[0]->null_value || args[1]->null_value))) return 0;
2530
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 955356 times.
 955360 if (val1 == 0) {
2531 4 signal_divide_by_null();
2532 4 return 0;
2533 }
2534
2535
4/4
✓ Branch 0 taken 955285 times.
✓ Branch 1 taken 71 times.
✓ Branch 2 taken 1325 times.
✓ Branch 3 taken 953960 times.
 955356 val0_negative = !args[0]->unsigned_flag && val0 < 0;
2536
3/4
✓ Branch 0 taken 955356 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 955352 times.
 955356 val1_negative = !args[1]->unsigned_flag && val1 < 0;
2537 955356 res_negative = val0_negative != val1_negative;
2538
4/4
✓ Branch 0 taken 1325 times.
✓ Branch 1 taken 954031 times.
✓ Branch 2 taken 1323 times.
✓ Branch 3 taken 2 times.
 955356 uval0 = (ulonglong)(val0_negative && val0 != LLONG_MIN ? -val0 : val0);
2539
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 955352 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 955356 uval1 = (ulonglong)(val1_negative && val1 != LLONG_MIN ? -val1 : val1);
2540 955356 res = uval0 / uval1;
2541
2/2
✓ Branch 0 taken 1325 times.
✓ Branch 1 taken 954031 times.
 955356 if (res_negative) {
2542
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1324 times.
 1325 if (res > (ulonglong)LLONG_MAX) return raise_integer_overflow();
2543 1324 res = (ulonglong)(-(longlong)res);
2544 }
2545 955355 return check_integer_overflow(res, !res_negative);
2546 }
2547
2548 849629 bool Item_func_div_int::resolve_type(THD *thd) {
2549 // Integer division forces result to be integer, so force arguments
2550 // that are parameters to be integer as well.
2551
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 849629 times.
 849629 if (param_type_uses_non_param(thd, MYSQL_TYPE_LONGLONG)) return true;
2552
2553
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 849626 times.
 849629 if (Item_func_div_base::resolve_type(thd)) return true;
2554 849626 set_nullable(true); // division by zero
2555
2556 849626 return false;
2557 }
2558
2559 849629 void Item_func_div_int::set_numeric_type() {
2560 849629 set_data_type_longlong();
2561 849629 hybrid_type = INT_RESULT;
2562 849629 result_precision();
2563 849629 }
2564
2565 3712887 longlong Item_func_mod::int_op() {
2566
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3712887 times.
 3712887 assert(fixed == 1);
2567 3712887 longlong val0 = args[0]->val_int();
2568
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3712889 times.
 3712889 if (current_thd->is_error()) return error_int();
2569 3712889 longlong val1 = args[1]->val_int();
2570
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3712889 times.
 3712889 if (current_thd->is_error()) return error_int();
2571 bool val0_negative, val1_negative;
2572 ulonglong uval0, uval1;
2573 ulonglong res;
2574
2575
6/6
✓ Branch 0 taken 3708095 times.
✓ Branch 1 taken 4794 times.
✓ Branch 2 taken 6565 times.
✓ Branch 3 taken 3701530 times.
✓ Branch 4 taken 11359 times.
✓ Branch 5 taken 3701530 times.
 3712889 if ((null_value = args[0]->null_value || args[1]->null_value))
2576 11359 return 0; /* purecov: inspected */
2577
2/2
✓ Branch 0 taken 3988 times.
✓ Branch 1 taken 3697542 times.
 3701530 if (val1 == 0) {
2578 3988 signal_divide_by_null();
2579 3988 return 0;
2580 }
2581
2582 /*
2583 '%' is calculated by integer division internally. Since dividing
2584 LLONG_MIN by -1 generates SIGFPE, we calculate using unsigned values and
2585 then adjust the sign appropriately.
2586 */
2587
4/4
✓ Branch 0 taken 3604819 times.
✓ Branch 1 taken 92723 times.
✓ Branch 2 taken 4215 times.
✓ Branch 3 taken 3600604 times.
 3697542 val0_negative = !args[0]->unsigned_flag && val0 < 0;
2588
4/4
✓ Branch 0 taken 3695366 times.
✓ Branch 1 taken 2176 times.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 3695301 times.
 3697542 val1_negative = !args[1]->unsigned_flag && val1 < 0;
2589
4/4
✓ Branch 0 taken 4215 times.
✓ Branch 1 taken 3693327 times.
✓ Branch 2 taken 4212 times.
✓ Branch 3 taken 3 times.
 3697542 uval0 = (ulonglong)(val0_negative && val0 != LLONG_MIN ? -val0 : val0);
2590
3/4
✓ Branch 0 taken 65 times.
✓ Branch 1 taken 3697477 times.
✓ Branch 2 taken 65 times.
✗ Branch 3 not taken.
 3697542 uval1 = (ulonglong)(val1_negative && val1 != LLONG_MIN ? -val1 : val1);
2591 3697542 res = uval0 % uval1;
2592 MY_COMPILER_DIAGNOSTIC_PUSH()
2593 // Suppress warning C4146 unary minus operator applied to unsigned type,
2594 // result still unsigned
2595 MY_COMPILER_MSVC_DIAGNOSTIC_IGNORE(4146)
2596
2/2
✓ Branch 0 taken 4215 times.
✓ Branch 1 taken 3693327 times.
 3697542 return check_integer_overflow(val0_negative ? -res : res, !val0_negative);
2597 MY_COMPILER_DIAGNOSTIC_POP()
2598 }
2599
2600 100251 double Item_func_mod::real_op() {
2601
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 100251 times.
 100251 assert(fixed == 1);
2602 100251 double val1 = args[0]->val_real();
2603
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 100251 times.
 100251 if (current_thd->is_error()) return error_real();
2604 100251 double val2 = args[1]->val_real();
2605
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 100251 times.
 100251 if (current_thd->is_error()) return error_real();
2606
2607
6/6
✓ Branch 0 taken 100231 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 100213 times.
✓ Branch 4 taken 38 times.
✓ Branch 5 taken 100213 times.
 100251 if ((null_value = args[0]->null_value || args[1]->null_value)) return 0.0;
2608
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 100209 times.
 100213 if (val2 == 0.0) {
2609 4 signal_divide_by_null();
2610 4 return 0.0;
2611 }
2612 100209 return fmod(val1, val2);
2613 }
2614
2615 62 my_decimal *Item_func_mod::decimal_op(my_decimal *decimal_value) {
2616 62 my_decimal value1, *val1;
2617 62 my_decimal value2, *val2;
2618
2619
1/2
✓ Branch 0 taken 62 times.
✗ Branch 1 not taken.
 62 val1 = args[0]->val_decimal(&value1);
2620
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
 62 if ((null_value = args[0]->null_value)) return nullptr;
2621
1/2
✓ Branch 0 taken 62 times.
✗ Branch 1 not taken.
 62 val2 = args[1]->val_decimal(&value2);
2622
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
 62 if ((null_value = args[1]->null_value)) return nullptr;
2623
3/5
✓ Branch 0 taken 62 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 53 times.
✓ Branch 3 taken 9 times.
✗ Branch 4 not taken.
 62 switch (my_decimal_mod(E_DEC_FATAL_ERROR & ~E_DEC_DIV_ZERO, decimal_value,
2624 val1, val2)) {
2625 53 case E_DEC_TRUNCATED:
2626 case E_DEC_OK:
2627 53 return decimal_value;
2628 9 case E_DEC_DIV_ZERO:
2629
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 signal_divide_by_null();
2630 [[fallthrough]];
2631 9 default:
2632 9 null_value = true;
2633 9 return nullptr;
2634 }
2635 62 }
2636
2637 135934 void Item_func_mod::result_precision() {
2638 135934 decimals = max(args[0]->decimals, args[1]->decimals);
2639 uint precision =
2640
1/2
✓ Branch 0 taken 135934 times.
✗ Branch 1 not taken.
 135934 max(args[0]->decimal_precision(), args[1]->decimal_precision());
2641
2642 271868 max_length = my_decimal_precision_to_length_no_truncation(precision, decimals,
2643 135934 unsigned_flag);
2644
2645 // Increase max_length if we have: signed % unsigned(precision == scale)
2646
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 135563 times.
 135566 if (!args[0]->unsigned_flag && args[1]->unsigned_flag &&
2647
5/6
✓ Branch 0 taken 135566 times.
✓ Branch 1 taken 368 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 135934 times.
 271502 args[0]->max_length <= args[1]->max_length &&
2648
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 args[1]->decimals == args[1]->decimal_precision()) {
2649 ✗ max_length += 1;
2650 }
2651 135934 }
2652
2653 144143 bool Item_func_mod::resolve_type(THD *thd) {
2654
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 144140 times.
 144143 if (Item_num_op::resolve_type(thd)) return true;
2655 144140 set_nullable(true);
2656 144140 unsigned_flag = args[0]->unsigned_flag;
2657 144140 return false;
2658 }
2659
2660 2049 double Item_func_neg::real_op() {
2661 2049 double value = args[0]->val_real();
2662 2049 null_value = args[0]->null_value;
2663 2049 return -value;
2664 }
2665
2666 155895 longlong Item_func_neg::int_op() {
2667 155895 longlong value = args[0]->val_int();
2668
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 155874 times.
 155895 if ((null_value = args[0]->null_value)) return 0;
2669
4/4
✓ Branch 0 taken 485 times.
✓ Branch 1 taken 155389 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 484 times.
 155874 if (args[0]->unsigned_flag && (ulonglong)value > (ulonglong)LLONG_MAX + 1ULL)
2670 1 return raise_integer_overflow();
2671 // For some platforms we need special handling of LLONG_MIN to
2672 // guarantee overflow.
2673
5/6
✓ Branch 0 taken 488 times.
✓ Branch 1 taken 155385 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 484 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
 155873 if (value == LLONG_MIN && !args[0]->unsigned_flag && !unsigned_flag)
2674 4 return raise_integer_overflow();
2675 // Avoid doing '-value' below, it is undefined.
2676
4/6
✓ Branch 0 taken 484 times.
✓ Branch 1 taken 155385 times.
✓ Branch 2 taken 484 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 484 times.
✗ Branch 5 not taken.
 155869 if (value == LLONG_MIN && args[0]->unsigned_flag && !unsigned_flag)
2677 484 return LLONG_MIN;
2678
3/4
✓ Branch 0 taken 155385 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8406 times.
✓ Branch 3 taken 146979 times.
 155385 return check_integer_overflow(-value, !args[0]->unsigned_flag && value < 0);
2679 }
2680
2681 3808 my_decimal *Item_func_neg::decimal_op(my_decimal *decimal_value) {
2682
1/2
✓ Branch 0 taken 3808 times.
✗ Branch 1 not taken.
 3808 my_decimal val, *value = args[0]->val_decimal(&val);
2683
1/2
✓ Branch 0 taken 3808 times.
✗ Branch 1 not taken.
 3808 if (!(null_value = args[0]->null_value)) {
2684
1/2
✓ Branch 0 taken 3808 times.
✗ Branch 1 not taken.
 3808 my_decimal2decimal(value, decimal_value);
2685
1/2
✓ Branch 0 taken 3808 times.
✗ Branch 1 not taken.
 3808 my_decimal_neg(decimal_value);
2686 3808 return decimal_value;
2687 }
2688 ✗ return nullptr;
2689 3808 }
2690
2691 143557 void Item_func_neg::fix_num_length_and_dec() {
2692 143557 decimals = args[0]->decimals;
2693
2/2
✓ Branch 0 taken 468 times.
✓ Branch 1 taken 143089 times.
 143557 max_length = args[0]->max_length + (args[0]->unsigned_flag ? 1 : 0);
2694 // Booleans have max_length = 1, but need to add the minus sign
2695
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 143552 times.
 143557 if (max_length == 1) max_length++;
2696 143557 }
2697
2698 143557 bool Item_func_neg::resolve_type(THD *thd) {
2699
1/2
✓ Branch 0 taken 143558 times.
✗ Branch 1 not taken.
 143557 DBUG_TRACE;
2700
3/4
✓ Branch 0 taken 143557 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 143556 times.
 143558 if (Item_func_num1::resolve_type(thd)) return true;
2701 /*
2702 If this is in integer context keep the context as integer if possible
2703 (This is how multiplication and other integer functions works)
2704 Use val() to get value as arg_type doesn't mean that item is
2705 Item_int or Item_real due to existence of Item_param.
2706 */
2707
7/8
✓ Branch 0 taken 139881 times.
✓ Branch 1 taken 3675 times.
✓ Branch 2 taken 139881 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 131989 times.
✓ Branch 5 taken 7892 times.
✓ Branch 6 taken 131987 times.
✓ Branch 7 taken 11569 times.
 275545 if (hybrid_type == INT_RESULT && args[0]->const_item() &&
2708
3/4
✓ Branch 0 taken 131989 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 131987 times.
✓ Branch 3 taken 2 times.
 131989 args[0]->may_eval_const_item(thd)) {
2709
1/2
✓ Branch 0 taken 131987 times.
✗ Branch 1 not taken.
 131987 longlong val = args[0]->val_int();
2710
6/6
✓ Branch 0 taken 772 times.
✓ Branch 1 taken 131215 times.
✓ Branch 2 taken 310 times.
✓ Branch 3 taken 462 times.
✓ Branch 4 taken 468 times.
✓ Branch 5 taken 131519 times.
 132297 if ((ulonglong)val >= (ulonglong)LLONG_MIN &&
2711 310 ((ulonglong)val != (ulonglong)LLONG_MIN ||
2712
3/4
✓ Branch 0 taken 310 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 304 times.
 310 args[0]->type() != INT_ITEM)) {
2713 /*
2714 Ensure that result is converted to DECIMAL, as longlong can't hold
2715 the negated number
2716 */
2717 468 unsigned_flag = false;
2718
2/4
✓ Branch 0 taken 468 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 468 times.
✗ Branch 3 not taken.
 468 set_data_type_decimal(args[0]->decimal_precision(), 0);
2719 468 hybrid_type = DECIMAL_RESULT;
2720
3/8
✓ Branch 0 taken 468 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 468 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 468 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 468 DBUG_PRINT("info", ("Type changed: DECIMAL_RESULT"));
2721 }
2722 }
2723 143556 unsigned_flag = false;
2724 143556 return false;
2725 143557 }
2726
2727 201 double Item_func_abs::real_op() {
2728 201 double value = args[0]->val_real();
2729 201 null_value = args[0]->null_value;
2730 201 return fabs(value);
2731 }
2732
2733 638117 longlong Item_func_abs::int_op() {
2734 638117 longlong value = args[0]->val_int();
2735
2/2
✓ Branch 0 taken 175 times.
✓ Branch 1 taken 637942 times.
 638117 if ((null_value = args[0]->null_value)) return 0;
2736
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 637939 times.
 637942 if (unsigned_flag) return value;
2737 /* -LLONG_MIN = LLONG_MAX + 1 => outside of signed longlong range */
2738
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 637938 times.
 637939 if (value == LLONG_MIN) return raise_integer_overflow();
2739 637938 return (value >= 0) ? value : -value;
2740 }
2741
2742 7 my_decimal *Item_func_abs::decimal_op(my_decimal *decimal_value) {
2743
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 my_decimal val, *value = args[0]->val_decimal(&val);
2744
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1 times.
 7 if (!(null_value = args[0]->null_value)) {
2745
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 my_decimal2decimal(value, decimal_value);
2746
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
 6 if (decimal_value->sign()) my_decimal_neg(decimal_value);
2747 6 return decimal_value;
2748 }
2749 1 return nullptr;
2750 7 }
2751
2752 2575 bool Item_func_abs::resolve_type(THD *thd) {
2753
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2574 times.
 2575 if (Item_func_num1::resolve_type(thd)) return true;
2754 2574 unsigned_flag = args[0]->unsigned_flag;
2755 2574 return false;
2756 }
2757
2758 1100 bool Item_dec_func::resolve_type(THD *thd) {
2759
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1100 times.
 1100 if (param_type_is_default(thd, 0, -1, MYSQL_TYPE_DOUBLE)) return true;
2760 1100 decimals = DECIMAL_NOT_SPECIFIED;
2761 1100 max_length = float_length(decimals);
2762 1100 set_nullable(true);
2763 1100 return reject_geometry_args(arg_count, args, this);
2764 }
2765
2766 /** Gateway to natural LOG function. */
2767 44 double Item_func_ln::val_real() {
2768
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44 times.
 44 assert(fixed == 1);
2769 44 double value = args[0]->val_real();
2770
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 43 times.
 44 if ((null_value = args[0]->null_value)) return 0.0;
2771
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 11 times.
 43 if (value <= 0.0) {
2772 32 signal_invalid_argument_for_log();
2773 32 return 0.0;
2774 }
2775 11 return log(value);
2776 }
2777
2778 /**
2779 Extended but so slower LOG function.
2780
2781 We have to check if all values are > zero and first one is not one
2782 as these are the cases then result is not a number.
2783 */
2784 41 double Item_func_log::val_real() {
2785
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.
 41 assert(fixed == 1);
2786 41 double value = args[0]->val_real();
2787
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 39 times.
 41 if ((null_value = args[0]->null_value)) return 0.0;
2788
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 32 times.
 39 if (value <= 0.0) {
2789 7 signal_invalid_argument_for_log();
2790 7 return 0.0;
2791 }
2792
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 16 times.
 32 if (arg_count == 2) {
2793 16 double value2 = args[1]->val_real();
2794
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if ((null_value = args[1]->null_value)) return 0.0;
2795
4/4
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 10 times.
 16 if (value2 <= 0.0 || value == 1.0) {
2796 6 signal_invalid_argument_for_log();
2797 6 return 0.0;
2798 }
2799 10 return log(value2) / log(value);
2800 }
2801 16 return log(value);
2802 }
2803
2804 25 double Item_func_log2::val_real() {
2805
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25 times.
 25 assert(fixed == 1);
2806 25 double value = args[0]->val_real();
2807
2808
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 23 times.
 25 if ((null_value = args[0]->null_value)) return 0.0;
2809
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 16 times.
 23 if (value <= 0.0) {
2810 7 signal_invalid_argument_for_log();
2811 7 return 0.0;
2812 }
2813 16 return std::log2(value);
2814 }
2815
2816 31 double Item_func_log10::val_real() {
2817
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 assert(fixed == 1);
2818 31 double value = args[0]->val_real();
2819
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 30 times.
 31 if ((null_value = args[0]->null_value)) return 0.0;
2820
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 22 times.
 30 if (value <= 0.0) {
2821 8 signal_invalid_argument_for_log();
2822 8 return 0.0;
2823 }
2824 22 return log10(value);
2825 }
2826
2827 45 double Item_func_exp::val_real() {
2828
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45 times.
 45 assert(fixed == 1);
2829 45 double value = args[0]->val_real();
2830
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45 times.
 45 if ((null_value = args[0]->null_value)) return 0.0; /* purecov: inspected */
2831 45 return check_float_overflow(exp(value));
2832 }
2833
2834 808 double Item_func_sqrt::val_real() {
2835
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 808 times.
 808 assert(fixed == 1);
2836 808 double value = args[0]->val_real();
2837
6/6
✓ Branch 0 taken 773 times.
✓ Branch 1 taken 35 times.
✓ Branch 2 taken 23 times.
✓ Branch 3 taken 750 times.
✓ Branch 4 taken 58 times.
✓ Branch 5 taken 750 times.
 808 if ((null_value = (args[0]->null_value || value < 0)))
2838 58 return 0.0; /* purecov: inspected */
2839 750 return sqrt(value);
2840 }
2841
2842 7153 double Item_func_pow::val_real() {
2843
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7153 times.
 7153 assert(fixed == 1);
2844 7153 double value = args[0]->val_real();
2845 7153 double val2 = args[1]->val_real();
2846
3/6
✓ Branch 0 taken 7153 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7153 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 7153 times.
 7153 if ((null_value = (args[0]->null_value || args[1]->null_value)))
2847 ✗ return 0.0; /* purecov: inspected */
2848 7153 const double pow_result = pow(value, val2);
2849 7153 return check_float_overflow(pow_result);
2850 }
2851
2852 // Trigonometric functions
2853
2854 28 double Item_func_acos::val_real() {
2855
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
 28 assert(fixed == 1);
2856 /* One can use this to defer SELECT processing. */
2857
1/2
✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
 28 DEBUG_SYNC(current_thd, "before_acos_function");
2858 28 double value = args[0]->val_real();
2859
6/8
✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 24 times.
✓ Branch 6 taken 4 times.
✓ Branch 7 taken 24 times.
 28 if ((null_value = (args[0]->null_value || (value < -1.0 || value > 1.0))))
2860 4 return 0.0;
2861 24 return acos(value);
2862 }
2863
2864 33 double Item_func_asin::val_real() {
2865
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33 times.
 33 assert(fixed == 1);
2866 33 double value = args[0]->val_real();
2867
7/8
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 22 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 18 times.
✓ Branch 6 taken 15 times.
✓ Branch 7 taken 18 times.
 33 if ((null_value = (args[0]->null_value || (value < -1.0 || value > 1.0))))
2868 15 return 0.0;
2869 18 return asin(value);
2870 }
2871
2872 41 double Item_func_atan::val_real() {
2873
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.
 41 assert(fixed == 1);
2874 41 double value = args[0]->val_real();
2875
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.
 41 if ((null_value = args[0]->null_value)) return 0.0;
2876
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 20 times.
 41 if (arg_count == 2) {
2877 21 double val2 = args[1]->val_real();
2878
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
 21 if ((null_value = args[1]->null_value)) return 0.0;
2879 21 return check_float_overflow(atan2(value, val2));
2880 }
2881 20 return atan(value);
2882 }
2883
2884 18 double Item_func_cos::val_real() {
2885
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
 18 assert(fixed == 1);
2886 18 double value = args[0]->val_real();
2887
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
 18 if ((null_value = args[0]->null_value)) return 0.0;
2888 18 return cos(value);
2889 }
2890
2891 94 double Item_func_sin::val_real() {
2892
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 94 times.
 94 assert(fixed == 1);
2893 94 double value = args[0]->val_real();
2894
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 93 times.
 94 if ((null_value = args[0]->null_value)) return 0.0;
2895 93 return sin(value);
2896 }
2897
2898 19 double Item_func_tan::val_real() {
2899
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
 19 assert(fixed == 1);
2900 19 double value = args[0]->val_real();
2901
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
 19 if ((null_value = args[0]->null_value)) return 0.0;
2902 19 return check_float_overflow(tan(value));
2903 }
2904
2905 17 double Item_func_cot::val_real() {
2906
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
 17 assert(fixed == 1);
2907 17 double value = args[0]->val_real();
2908
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 14 times.
 17 if ((null_value = args[0]->null_value)) return 0.0;
2909 14 double val2 = tan(value);
2910
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 5 times.
 14 if (val2 == 0.0) {
2911 9 return raise_float_overflow();
2912 }
2913 5 return check_float_overflow(1.0 / val2);
2914 }
2915
2916 // Bitwise functions
2917
2918 90699 bool Item_func_bit::resolve_type(THD *thd) {
2919 90699 const bool second_arg = binary_result_requires_binary_second_arg();
2920 /*
2921 In ?&?, we assume varbinary; if integer is provided we'll re-prepare.
2922 To force var*binary*, we temporarily change the charset:
2923 */
2924 90699 const CHARSET_INFO *save_cs = thd->variables.collation_connection;
2925 90699 thd->variables.collation_connection = &my_charset_bin;
2926
2/2
✓ Branch 0 taken 30542 times.
✓ Branch 1 taken 60157 times.
 90699 if (second_arg) {
2927
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30542 times.
 30542 if (param_type_uses_non_param(thd)) return true;
2928 } else {
2929
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 60157 times.
 60157 if (param_type_is_default(thd, 0, 1)) return true;
2930
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 60157 times.
 60157 if (param_type_is_default(thd, 1, 2, MYSQL_TYPE_LONGLONG)) return true;
2931 }
2932 90699 thd->variables.collation_connection = save_cs;
2933
4/4
✓ Branch 0 taken 30542 times.
✓ Branch 1 taken 60157 times.
✓ Branch 2 taken 72 times.
✓ Branch 3 taken 90627 times.
 90699 if (bit_func_returns_binary(args[0], second_arg ? args[1] : nullptr)) {
2934 72 hybrid_type = STRING_RESULT;
2935 72 set_data_type_string(
2936
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 22 times.
 144 max<uint32>(args[0]->max_length, second_arg ? args[1]->max_length : 0U),
2937 &my_charset_bin);
2938 } else {
2939 90627 hybrid_type = INT_RESULT;
2940 90627 set_data_type_longlong();
2941 90627 unsigned_flag = true;
2942 }
2943 90699 return reject_geometry_args(arg_count, args, this);
2944 }
2945
2946 88228 longlong Item_func_bit::val_int() {
2947
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 88228 times.
 88228 assert(fixed);
2948
1/2
✓ Branch 0 taken 88228 times.
✗ Branch 1 not taken.
 88228 if (hybrid_type == INT_RESULT)
2949 88228 return int_op();
2950 else {
2951 String *res;
2952 ✗ if (!(res = str_op(&str_value))) return 0;
2953
2954 int ovf_error;
2955 ✗ const char *from = res->ptr();
2956 ✗ size_t len = res->length();
2957 ✗ const char *end = from + len;
2958 ✗ return my_strtoll10(from, &end, &ovf_error);
2959 }
2960 }
2961
2962 6 double Item_func_bit::val_real() {
2963
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 assert(fixed);
2964
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (hybrid_type == INT_RESULT)
2965 6 return static_cast<ulonglong>(int_op());
2966 else {
2967 String *res;
2968 ✗ if (!(res = str_op(&str_value))) return 0.0;
2969
2970 int ovf_error;
2971 ✗ const char *from = res->ptr();
2972 ✗ size_t len = res->length();
2973 ✗ const char *end = from + len;
2974 ✗ return my_strtod(from, &end, &ovf_error);
2975 }
2976 }
2977
2978 13090 my_decimal *Item_func_bit::val_decimal(my_decimal *decimal_value) {
2979
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13090 times.
 13090 assert(fixed);
2980
1/2
✓ Branch 0 taken 13090 times.
✗ Branch 1 not taken.
 13090 if (hybrid_type == INT_RESULT)
2981 13090 return val_decimal_from_int(decimal_value);
2982 else
2983 ✗ return val_decimal_from_string(decimal_value);
2984 }
2985
2986 505 String *Item_func_bit::val_str(String *str) {
2987
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 505 times.
 505 assert(fixed);
2988
2/2
✓ Branch 0 taken 65 times.
✓ Branch 1 taken 440 times.
 505 if (hybrid_type == INT_RESULT) {
2989 65 longlong nr = int_op();
2990
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
 65 if (null_value) return nullptr;
2991 65 str->set_int(nr, unsigned_flag, collation.collation);
2992 65 return str;
2993 } else
2994 440 return str_op(str);
2995 }
2996
2997 // Shift-functions, same as << and >> in C/C++
2998
2999 /**
3000 Template function that evaluates the bitwise shift operation over integer
3001 arguments.
3002 @tparam to_left True if left-shift, false if right-shift
3003 */
3004 template <bool to_left>
3005 119616 longlong Item_func_shift::eval_int_op() {
3006
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 59808 times.
 119616 assert(fixed);
3007 119616 ulonglong res = args[0]->val_uint();
3008
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 59808 times.
 119616 if (args[0]->null_value) return error_int();
3009
3010 119616 ulonglong shift = args[1]->val_uint();
3011
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 59808 times.
 119616 if (args[1]->null_value) return error_int();
3012
3013 119616 null_value = false;
3014
2/2
✓ Branch 0 taken 59793 times.
✓ Branch 1 taken 15 times.
 119616 if (shift < sizeof(longlong) * 8)
3015 119586 return to_left ? (res << shift) : (res >> shift);
3016 30 return 0;
3017 }
3018
3019 /// Instantiations of the above
3020 template longlong Item_func_shift::eval_int_op<true>();
3021 template longlong Item_func_shift::eval_int_op<false>();
3022
3023 /**
3024 Template function that evaluates the bitwise shift operation over binary
3025 string arguments.
3026 @tparam to_left True if left-shift, false if right-shift
3027 */
3028 template <bool to_left>
3029 98 String *Item_func_shift::eval_str_op(String *) {
3030
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 49 times.
 98 assert(fixed);
3031
3032 98 String tmp_str;
3033
1/2
✓ Branch 0 taken 49 times.
✗ Branch 1 not taken.
 98 String *arg = args[0]->val_str(&tmp_str);
3034
4/6
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 48 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 98 if (!arg || args[0]->null_value) return error_str();
3035
3036 96 ssize_t arg_length = arg->length();
3037 96 size_t shift =
3038
1/2
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
 96 min(args[1]->val_uint(), static_cast<ulonglong>(arg_length) * 8);
3039
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 96 if (args[1]->null_value) return error_str();
3040
3041
2/6
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 48 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 96 if (tmp_value.alloc(arg->length())) return error_str();
3042
3043 96 tmp_value.length(arg_length);
3044 96 tmp_value.set_charset(&my_charset_bin);
3045 /*
3046 Example with left-shift-by-21-bits:
3047 |........|........|........|........|
3048 byte i byte i+1 byte i+2 byte i+3
3049 First (leftmost) bit has number 1.
3050 21 = 2*8 + 5.
3051 Bits of number 1-3 of byte 'i' receive bits 22-24 i.e. the last 3 bits of
3052 byte 'i+2'. So, take byte 'i+2', shift it left by 5 bits, that puts the
3053 last 3 bits of byte 'i+2' in bits 1-3, and 0s elsewhere.
3054 Bits of number 4-8 of byte 'i' receive bits 25-39 i.e. the first 5 bits of
3055 byte 'i+3'. So, take byte 'i+3', shift it right by 3 bits, that puts the
3056 first 5 bits of byte 'i+3' in bits 4-8, and 0s elsewhere.
3057 In total, do OR of both results.
3058 */
3059 96 size_t mod = shift % 8;
3060 96 size_t mod_complement = 8 - mod;
3061 96 ssize_t entire_bytes = shift / 8;
3062
3063 96 const unsigned char *from_c = pointer_cast<const unsigned char *>(arg->ptr());
3064 96 unsigned char *to_c = pointer_cast<unsigned char *>(tmp_value.c_ptr_quick());
3065
3066 if (to_left) {
3067 // Bytes of lower index are overwritten by bytes of higher index
3068
2/2
✓ Branch 0 taken 252 times.
✓ Branch 1 taken 24 times.
 552 for (ssize_t i = 0; i < arg_length; i++)
3069
2/2
✓ Branch 0 taken 228 times.
✓ Branch 1 taken 24 times.
 504 if (i + entire_bytes + 1 < arg_length)
3070 456 to_c[i] = (from_c[i + entire_bytes] << mod) |
3071 456 (from_c[i + entire_bytes + 1] >> mod_complement);
3072
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 48 else if (i + entire_bytes + 1 == arg_length)
3073 48 to_c[i] = from_c[i + entire_bytes] << mod;
3074 else
3075 ✗ to_c[i] = 0;
3076 } else {
3077 // Bytes of higher index are overwritten by bytes of lower index
3078
2/2
✓ Branch 0 taken 252 times.
✓ Branch 1 taken 24 times.
 552 for (ssize_t i = arg_length - 1; i >= 0; i--)
3079
2/2
✓ Branch 0 taken 228 times.
✓ Branch 1 taken 24 times.
 504 if (i > entire_bytes)
3080 456 to_c[i] = (from_c[i - entire_bytes] >> mod) |
3081 456 (from_c[i - entire_bytes - 1] << mod_complement);
3082
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 48 else if (i == entire_bytes)
3083 48 to_c[i] = from_c[i - entire_bytes] >> mod;
3084 else
3085 ✗ to_c[i] = 0;
3086 }
3087
3088 96 null_value = false;
3089 96 return &tmp_value;
3090 98 }
3091
3092 /// Instantiations of the above
3093 template String *Item_func_shift::eval_str_op<true>(String *);
3094 template String *Item_func_shift::eval_str_op<false>(String *);
3095
3096 // Bit negation ('~')
3097
3098 23 longlong Item_func_bit_neg::int_op() {
3099
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23 times.
 23 assert(fixed);
3100 23 ulonglong res = (ulonglong)args[0]->val_int();
3101
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 22 times.
 23 if (args[0]->null_value) return error_int();
3102 22 null_value = false;
3103 22 return ~res;
3104 }
3105
3106 55 String *Item_func_bit_neg::str_op(String *str) {
3107
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 55 times.
 55 assert(fixed);
3108 55 String *res = args[0]->val_str(str);
3109
3/4
✓ Branch 0 taken 54 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 54 times.
 55 if (args[0]->null_value || !res) return error_str();
3110
3111
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54 times.
 54 if (tmp_value.alloc(res->length())) return error_str();
3112
3113 54 size_t arg_length = res->length();
3114 54 tmp_value.length(arg_length);
3115 54 tmp_value.set_charset(&my_charset_bin);
3116 54 const unsigned char *from_c = pointer_cast<const unsigned char *>(res->ptr());
3117 54 unsigned char *to_c = pointer_cast<unsigned char *>(tmp_value.c_ptr_quick());
3118 54 size_t i = 0;
3119
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 54 times.
 117 while (i + sizeof(longlong) <= arg_length) {
3120 63 int8store(&to_c[i], ~(uint8korr(&from_c[i])));
3121 63 i += sizeof(longlong);
3122 }
3123
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 54 times.
 117 while (i < arg_length) {
3124 63 to_c[i] = ~from_c[i];
3125 63 i++;
3126 }
3127
3128 54 null_value = false;
3129 54 return &tmp_value;
3130 }
3131
3132 /**
3133 Template function used to evaluate the bitwise operation over int arguments.
3134
3135 @param int_func The bitwise function.
3136 */
3137 template <class Int_func>
3138 56936 longlong Item_func_bit_two_param::eval_int_op(Int_func int_func) {
3139
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28468 times.
 56936 assert(fixed);
3140
1/2
✓ Branch 0 taken 28468 times.
✗ Branch 1 not taken.
 56936 ulonglong arg0 = args[0]->val_uint();
3141
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 28460 times.
 56936 if (args[0]->null_value) return error_int();
3142
1/2
✓ Branch 0 taken 28460 times.
✗ Branch 1 not taken.
 56920 ulonglong arg1 = args[1]->val_uint();
3143
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 28456 times.
 56920 if (args[1]->null_value) return error_int();
3144 56912 null_value = false;
3145 56912 return (longlong)int_func(arg0, arg1);
3146 }
3147
3148 /// Instantiations of the above
3149 template longlong Item_func_bit_two_param::eval_int_op<std::bit_or<ulonglong>>(
3150 std::bit_or<ulonglong>);
3151 template longlong Item_func_bit_two_param::eval_int_op<std::bit_and<ulonglong>>(
3152 std::bit_and<ulonglong>);
3153 template longlong Item_func_bit_two_param::eval_int_op<std::bit_xor<ulonglong>>(
3154 std::bit_xor<ulonglong>);
3155
3156 /**
3157 Template function that evaluates the bitwise operation over binary arguments.
3158 Checks that both arguments have same length and applies the bitwise operation
3159
3160 @param char_func The Bitwise function used to evaluate unsigned chars.
3161 @param int_func The Bitwise function used to evaluate unsigned long longs.
3162 */
3163 template <class Char_func, class Int_func>
3164 672 String *Item_func_bit_two_param::eval_str_op(String *, Char_func char_func,
3165 Int_func int_func) {
3166
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 336 times.
 672 assert(fixed);
3167 672 String arg0_buff;
3168
1/2
✓ Branch 0 taken 336 times.
✗ Branch 1 not taken.
 672 String *s1 = args[0]->val_str(&arg0_buff);
3169
3170
2/6
✓ Branch 0 taken 336 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 336 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 672 if (args[0]->null_value || !s1) return error_str();
3171
3172 672 String arg1_buff;
3173
1/2
✓ Branch 0 taken 336 times.
✗ Branch 1 not taken.
 672 String *s2 = args[1]->val_str(&arg1_buff);
3174
3175
4/6
✓ Branch 0 taken 174 times.
✓ Branch 1 taken 162 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 174 times.
✓ Branch 4 taken 162 times.
✗ Branch 5 not taken.
 672 if (args[1]->null_value || !s2) return error_str();
3176
3177 348 size_t arg_length = s1->length();
3178
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 171 times.
 348 if (arg_length != s2->length()) {
3179
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 6 my_error(ER_INVALID_BITWISE_OPERANDS_SIZE, MYF(0), func_name());
3180
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 6 return error_str();
3181 }
3182
3183
2/6
✓ Branch 0 taken 171 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 171 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 342 if (tmp_value.alloc(arg_length)) return error_str();
3184
3185 342 tmp_value.length(arg_length);
3186 342 tmp_value.set_charset(&my_charset_bin);
3187
3188 342 const uchar *s1_c_p = pointer_cast<const uchar *>(s1->ptr());
3189 342 const uchar *s2_c_p = pointer_cast<const uchar *>(s2->ptr());
3190 342 char *res = tmp_value.ptr();
3191 342 size_t i = 0;
3192
2/2
✓ Branch 0 taken 189 times.
✓ Branch 1 taken 171 times.
 720 while (i + sizeof(longlong) <= arg_length) {
3193 378 int8store(&res[i], int_func(uint8korr(&s1_c_p[i]), uint8korr(&s2_c_p[i])));
3194 378 i += sizeof(longlong);
3195 }
3196
2/2
✓ Branch 0 taken 207 times.
✓ Branch 1 taken 171 times.
 756 while (i < arg_length) {
3197 414 res[i] = char_func(s1_c_p[i], s2_c_p[i]);
3198 414 i++;
3199 }
3200
3201 342 null_value = false;
3202 342 return &tmp_value;
3203 672 }
3204
3205 /// Instantiations of the above
3206 template String *
3207 Item_func_bit_two_param::eval_str_op<std::bit_or<char>, std::bit_or<ulonglong>>(
3208 String *, std::bit_or<char>, std::bit_or<ulonglong>);
3209 template String *Item_func_bit_two_param::eval_str_op<
3210 std::bit_and<char>, std::bit_and<ulonglong>>(String *, std::bit_and<char>,
3211 std::bit_and<ulonglong>);
3212 template String *Item_func_bit_two_param::eval_str_op<
3213 std::bit_xor<char>, std::bit_xor<ulonglong>>(String *, std::bit_xor<char>,
3214 std::bit_xor<ulonglong>);
3215
3216 91311 bool Item::bit_func_returns_binary(const Item *a, const Item *b) {
3217 /*
3218 Checks if the bitwise function should return binary data.
3219 The conditions to return true are the following:
3220
3221 1. If there's only one argument(so b is nullptr),
3222 then a must be a [VAR]BINARY Item, different from the hex/bit/NULL literal.
3223
3224 2. If there are two arguments, both should be [VAR]BINARY
3225 and at least one of them should be different from the hex/bit/NULL literal
3226 */
3227 // Check if a is [VAR]BINARY Item
3228
2/2
✓ Branch 0 taken 1189 times.
✓ Branch 1 taken 90122 times.
 92500 bool a_is_binary = a->result_type() == STRING_RESULT &&
3229
2/2
✓ Branch 0 taken 1170 times.
✓ Branch 1 taken 19 times.
 1189 a->collation.collation == &my_charset_bin;
3230 // Check if b is not null and is [VAR]BINARY Item
3231
4/4
✓ Branch 0 taken 30542 times.
✓ Branch 1 taken 60769 times.
✓ Branch 2 taken 201 times.
✓ Branch 3 taken 30341 times.
 91512 bool b_is_binary = b && b->result_type() == STRING_RESULT &&
3232
2/2
✓ Branch 0 taken 195 times.
✓ Branch 1 taken 6 times.
 201 b->collation.collation == &my_charset_bin;
3233
3234
6/6
✓ Branch 0 taken 1170 times.
✓ Branch 1 taken 90141 times.
✓ Branch 2 taken 603 times.
✓ Branch 3 taken 567 times.
✓ Branch 4 taken 122 times.
✓ Branch 5 taken 481 times.
 92000 return a_is_binary && (!b || b_is_binary) &&
3235
5/6
✓ Branch 0 taken 575 times.
✓ Branch 1 taken 114 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 575 times.
✓ Branch 4 taken 72 times.
✓ Branch 5 taken 42 times.
 689 ((a->type() != Item::VARBIN_ITEM && a->type() != Item::NULL_ITEM) ||
3236
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
 72 (b && b->type() != Item::VARBIN_ITEM &&
3237
0/2
✗ Branch 0 not taken.
✗ Branch 1 not taken.
 91311 b->type() != Item::NULL_ITEM));
3238 }
3239
3240 // Conversion functions
3241
3242 111646 bool Item_func_int_val::resolve_type_inner(THD *) {
3243
1/2
✓ Branch 0 taken 111646 times.
✗ Branch 1 not taken.
 111646 DBUG_TRACE;
3244
3/10
✓ Branch 0 taken 111646 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 111646 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 111646 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 111646 DBUG_PRINT("info", ("name %s", func_name()));
3245
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 111646 times.
 111646 assert(args[0]->data_type() != MYSQL_TYPE_INVALID);
3246
3247
3/4
✓ Branch 0 taken 111646 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 111642 times.
 111646 if (reject_geometry_args(arg_count, args, this)) return true;
3248
3249
4/6
✓ Branch 0 taken 111642 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 101980 times.
✓ Branch 3 taken 85 times.
✓ Branch 4 taken 9577 times.
✗ Branch 5 not taken.
 111642 switch (args[0]->result_type()) {
3250 101980 case STRING_RESULT:
3251 case REAL_RESULT:
3252
1/2
✓ Branch 0 taken 101980 times.
✗ Branch 1 not taken.
 101980 set_data_type_double();
3253 101980 hybrid_type = REAL_RESULT;
3254 101980 break;
3255 85 case INT_RESULT:
3256
1/2
✓ Branch 0 taken 85 times.
✗ Branch 1 not taken.
 85 set_data_type_longlong();
3257 85 unsigned_flag = args[0]->unsigned_flag;
3258 85 hybrid_type = INT_RESULT;
3259 85 break;
3260 9577 case DECIMAL_RESULT: {
3261 // For historical reasons, CEILING and FLOOR convert DECIMAL inputs into
3262 // BIGINT (granted that they are small enough to fit) while ROUND and
3263 // TRUNCATE don't. As items are not yet evaluated at this point,
3264 // assumptions must be made about when a conversion from DECIMAL_RESULT to
3265 // INT_RESULT can be safely achieved.
3266 //
3267 // During the rounding operation, we account for signedness by always
3268 // assuming that the argument DECIMAL is signed. Additionally, since we
3269 // call set_data_type_decimal with a scale of 0, we must increment the
3270 // precision here, as the rounding operation may cause an increase in
3271 // order of magnitude.
3272
1/2
✓ Branch 0 taken 9577 times.
✗ Branch 1 not taken.
 9577 int precision = args[0]->decimal_precision() - args[0]->decimals;
3273
2/2
✓ Branch 0 taken 9559 times.
✓ Branch 1 taken 18 times.
 9577 if (args[0]->decimals != 0) ++precision;
3274
1/2
✓ Branch 0 taken 9577 times.
✗ Branch 1 not taken.
 9577 set_data_type_decimal(precision, 0);
3275 9577 hybrid_type = DECIMAL_RESULT;
3276
3277 // The max_length of the biggest INT_RESULT, BIGINT, is 20 regardless of
3278 // signedness, as a minus sign will be counted as one digit. A DECIMAL of
3279 // length 20 could be bigger than the max BIGINT value, thus requiring a
3280 // length < 20. DECIMAL_LONGLONG_DIGITS value is 22, which is presumably
3281 // the sum of 20 digits, a minus sign and a decimal point; requiring -2
3282 // when considering the conversion.
3283
2/2
✓ Branch 0 taken 9540 times.
✓ Branch 1 taken 37 times.
 9577 if (max_length < (DECIMAL_LONGLONG_DIGITS - 2)) {
3284
1/2
✓ Branch 0 taken 9540 times.
✗ Branch 1 not taken.
 9540 set_data_type_longlong();
3285 9540 hybrid_type = INT_RESULT;
3286 }
3287
3288 9577 break;
3289 }
3290 ✗ default:
3291 ✗ assert(0);
3292 }
3293
3/14
✓ Branch 0 taken 111642 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 111642 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 111642 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
 111642 DBUG_PRINT("info", ("Type: %s", (hybrid_type == REAL_RESULT
3294 ? "REAL_RESULT"
3295 : hybrid_type == DECIMAL_RESULT
3296 ? "DECIMAL_RESULT"
3297 : hybrid_type == INT_RESULT
3298 ? "INT_RESULT"
3299 : "--ILLEGAL!!!--")));
3300
3301 111642 return false;
3302 111646 }
3303
3304 293 longlong Item_func_ceiling::int_op() {
3305 longlong result;
3306
3/5
✓ Branch 0 taken 293 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 280 times.
✗ Branch 4 not taken.
 293 switch (args[0]->result_type()) {
3307 13 case INT_RESULT:
3308
1/2
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
 13 result = args[0]->val_int();
3309 13 null_value = args[0]->null_value;
3310 13 break;
3311 280 case DECIMAL_RESULT: {
3312 280 my_decimal dec_buf, *dec;
3313
2/4
✓ Branch 0 taken 280 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 280 times.
✗ Branch 3 not taken.
 280 if ((dec = Item_func_ceiling::decimal_op(&dec_buf)))
3314
1/2
✓ Branch 0 taken 280 times.
✗ Branch 1 not taken.
 280 my_decimal2int(E_DEC_FATAL_ERROR, dec, unsigned_flag, &result);
3315 else
3316 ✗ result = 0;
3317 280 break;
3318 280 }
3319 ✗ default:
3320 ✗ result = (longlong)Item_func_ceiling::real_op();
3321 };
3322 293 return result;
3323 }
3324
3325 12 double Item_func_ceiling::real_op() {
3326 12 double value = args[0]->val_real();
3327 12 null_value = args[0]->null_value;
3328 12 return ceil(value);
3329 }
3330
3331 286 my_decimal *Item_func_ceiling::decimal_op(my_decimal *decimal_value) {
3332
1/2
✓ Branch 0 taken 286 times.
✗ Branch 1 not taken.
 286 my_decimal val, *value = args[0]->val_decimal(&val);
3333
1/2
✓ Branch 0 taken 286 times.
✗ Branch 1 not taken.
 286 if (!(null_value =
3334
1/2
✓ Branch 0 taken 286 times.
✗ Branch 1 not taken.
 572 (args[0]->null_value ||
3335
2/4
✓ Branch 0 taken 286 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 286 times.
 286 my_decimal_ceiling(E_DEC_FATAL_ERROR, value, decimal_value) > 1)))
3336 286 return decimal_value;
3337 ✗ return nullptr;
3338 286 }
3339
3340 53475 longlong Item_func_floor::int_op() {
3341 longlong result;
3342
3/5
✓ Branch 0 taken 53475 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
✓ Branch 3 taken 53444 times.
✗ Branch 4 not taken.
 53475 switch (args[0]->result_type()) {
3343 31 case INT_RESULT:
3344
1/2
✓ Branch 0 taken 31 times.
✗ Branch 1 not taken.
 31 result = args[0]->val_int();
3345 31 null_value = args[0]->null_value;
3346 31 break;
3347 53444 case DECIMAL_RESULT: {
3348 53444 my_decimal dec_buf, *dec;
3349
2/4
✓ Branch 0 taken 53444 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 53444 times.
✗ Branch 3 not taken.
 53444 if ((dec = Item_func_floor::decimal_op(&dec_buf)))
3350
1/2
✓ Branch 0 taken 53444 times.
✗ Branch 1 not taken.
 53444 my_decimal2int(E_DEC_FATAL_ERROR, dec, unsigned_flag, &result);
3351 else
3352 ✗ result = 0;
3353 53444 break;
3354 53444 }
3355 ✗ default:
3356 ✗ result = (longlong)Item_func_floor::real_op();
3357 };
3358 53475 return result;
3359 }
3360
3361 637404 double Item_func_floor::real_op() {
3362 637404 double value = args[0]->val_real();
3363 637405 null_value = args[0]->null_value;
3364 637405 return floor(value);
3365 }
3366
3367 427601 my_decimal *Item_func_floor::decimal_op(my_decimal *decimal_value) {
3368
1/2
✓ Branch 0 taken 427601 times.
✗ Branch 1 not taken.
 427601 my_decimal val, *value = args[0]->val_decimal(&val);
3369
1/2
✓ Branch 0 taken 427601 times.
✗ Branch 1 not taken.
 427601 if (!(null_value =
3370
1/2
✓ Branch 0 taken 427601 times.
✗ Branch 1 not taken.
 855202 (args[0]->null_value ||
3371
2/4
✓ Branch 0 taken 427601 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 427601 times.
 427601 my_decimal_floor(E_DEC_FATAL_ERROR, value, decimal_value) > 1)))
3372 427601 return decimal_value;
3373 ✗ return nullptr;
3374 427601 }
3375
3376 90218 bool Item_func_round::resolve_type(THD *thd) {
3377
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 90218 times.
 90218 if (param_type_is_default(thd, 0, 1, MYSQL_TYPE_NEWDECIMAL)) return true;
3378
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 90218 times.
 90218 if (param_type_is_default(thd, 1, 2, MYSQL_TYPE_LONGLONG)) return true;
3379
3380
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 90216 times.
 90218 if (reject_geometry_args(arg_count, args, this)) return true;
3381
3382
3/4
✓ Branch 0 taken 34 times.
✓ Branch 1 taken 79761 times.
✓ Branch 2 taken 10421 times.
✗ Branch 3 not taken.
 90216 switch (args[0]->result_type()) {
3383 34 case INT_RESULT:
3384 34 set_data_type_longlong();
3385 34 unsigned_flag = args[0]->unsigned_flag;
3386 34 hybrid_type = INT_RESULT;
3387 34 break;
3388 79761 case DECIMAL_RESULT: {
3389 /*
3390 If the rounding precision is known at this stage (constant), use it
3391 to adjust the precision and scale of the result to the minimal
3392 values that will accommodate the answer. Otherwise, use the precision
3393 and scale from the first argument.
3394 If wanted scale is less than argument's scale, reduce it accordingly.
3395 When rounding, make sure to accommodate one extra digit in precision
3396 Example: ROUND(99.999, 2). Here, the type of the argument is
3397 DECIMAL(5, 3). The type of the result is DECIMAL(5,2), since the
3398 result of this operation is 100.00.
3399 Also make sure that precision is greater than zero.
3400 */
3401 longlong val1;
3402
5/6
✓ Branch 0 taken 79737 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 79737 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 79737 times.
✓ Branch 5 taken 24 times.
 79761 if (args[1]->const_item() && args[1]->may_eval_const_item(thd)) {
3403 79737 val1 = args[1]->val_int();
3404
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 79735 times.
 79737 if ((null_value = args[1]->is_null())) {
3405 2 val1 = 0;
3406 }
3407
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 79733 times.
 79737 if (args[1]->unsigned_flag) {
3408
2/4
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 4 if (val1 > DECIMAL_MAX_SCALE || val1 < 0) val1 = DECIMAL_MAX_SCALE;
3409
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 79722 times.
 79733 } else if (val1 > DECIMAL_MAX_SCALE) {
3410 11 val1 = DECIMAL_MAX_SCALE;
3411
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 79714 times.
 79722 } else if (val1 < -DECIMAL_MAX_SCALE) {
3412 8 val1 = -DECIMAL_MAX_SCALE;
3413 }
3414 } else {
3415 24 val1 = args[0]->decimals;
3416 }
3417
3418 79761 uint8 precision = args[0]->decimal_precision();
3419 79761 uint8 new_scale = args[0]->decimals;
3420
2/2
✓ Branch 0 taken 67561 times.
✓ Branch 1 taken 12200 times.
 79761 if (val1 <= 0) {
3421 67561 precision -= new_scale;
3422
2/2
✓ Branch 0 taken 67529 times.
✓ Branch 1 taken 32 times.
 67561 if (!truncate) precision += 1;
3423 67561 new_scale = 0;
3424
2/2
✓ Branch 0 taken 6522 times.
✓ Branch 1 taken 5678 times.
 12200 } else if (val1 < new_scale) {
3425 6522 precision -= (new_scale - val1);
3426
2/2
✓ Branch 0 taken 6506 times.
✓ Branch 1 taken 16 times.
 6522 if (!truncate) precision += 1;
3427 6522 new_scale = val1;
3428 }
3429
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 79759 times.
 79761 if (precision == 0) precision = 1;
3430 79761 set_data_type_decimal(precision, new_scale);
3431 79761 hybrid_type = DECIMAL_RESULT;
3432 79761 break;
3433 }
3434 10421 case REAL_RESULT:
3435 case STRING_RESULT:
3436 10421 set_data_type_double();
3437 10421 hybrid_type = REAL_RESULT;
3438 10421 break;
3439 ✗ default:
3440 ✗ assert(0); /* This result type isn't handled */
3441 }
3442 90216 return false;
3443 }
3444
3445 40892 double my_double_round(double value, longlong dec, bool dec_unsigned,
3446 bool truncate) {
3447
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 40884 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
 40892 bool dec_negative = (dec < 0) && !dec_unsigned;
3448 40892 int log_10_size = array_elements(log_10); // 309
3449
4/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 40884 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 5 times.
 40892 if (dec_negative && dec <= -log_10_size) return 0.0;
3450
3451
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 40884 times.
 40889 ulonglong abs_dec = dec_negative ? -dec : dec;
3452
3453
2/2
✓ Branch 0 taken 24419 times.
✓ Branch 1 taken 16470 times.
 40889 double tmp = (abs_dec < array_elements(log_10) ? log_10[abs_dec]
3454 16470 : pow(10.0, (double)abs_dec));
3455
3456 40889 double value_mul_tmp = value * tmp;
3457
6/6
✓ Branch 0 taken 40884 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 16481 times.
✓ Branch 3 taken 24403 times.
✓ Branch 4 taken 16481 times.
✓ Branch 5 taken 24408 times.
 40889 if (!dec_negative && !std::isfinite(value_mul_tmp)) return value;
3458
3459 24408 double value_div_tmp = value / tmp;
3460
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 24344 times.
 24408 if (truncate) {
3461
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
 64 if (value >= 0.0)
3462
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 63 times.
 64 return dec < 0 ? floor(value_div_tmp) * tmp : floor(value_mul_tmp) / tmp;
3463 else
3464 ✗ return dec < 0 ? ceil(value_div_tmp) * tmp : ceil(value_mul_tmp) / tmp;
3465 }
3466
3467
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 24340 times.
 24344 return dec < 0 ? rint(value_div_tmp) * tmp : rint(value_mul_tmp) / tmp;
3468 }
3469
3470 23215 double Item_func_round::real_op() {
3471 23215 const double value = args[0]->val_real();
3472 23215 const longlong decimal_places = args[1]->val_int();
3473
3474
6/6
✓ Branch 0 taken 23214 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 23213 times.
✓ Branch 4 taken 23213 times.
✓ Branch 5 taken 2 times.
 23215 if (!(null_value = args[0]->null_value || args[1]->null_value))
3475 46426 return my_double_round(value, decimal_places, args[1]->unsigned_flag,
3476 23213 truncate);
3477
3478 2 return 0.0;
3479 }
3480
3481 /*
3482 Rounds a given value to a power of 10 specified as the 'to' argument.
3483 */
3484 123 static inline ulonglong my_unsigned_round(ulonglong value, ulonglong to,
3485 bool *round_overflow) {
3486 123 ulonglong tmp = value / to * to;
3487
2/2
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 55 times.
 123 if (value - tmp < (to >> 1)) {
3488 68 return tmp;
3489 } else {
3490
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 46 times.
 55 if (test_if_sum_overflows_ull(tmp, to)) {
3491 9 *round_overflow = true;
3492 9 return 0;
3493 }
3494 46 return tmp + to;
3495 }
3496 }
3497
3498 178 longlong Item_func_round::int_op() {
3499 178 longlong value = args[0]->val_int();
3500 178 longlong dec = args[1]->val_int();
3501 178 decimals = 0;
3502 ulonglong abs_dec;
3503
3/6
✓ Branch 0 taken 178 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 178 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 178 times.
 178 if ((null_value = args[0]->null_value || args[1]->null_value)) return 0;
3504
4/4
✓ Branch 0 taken 162 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 158 times.
 178 if ((dec >= 0) || args[1]->unsigned_flag)
3505 20 return value; // integer have not digits after point
3506
3507 MY_COMPILER_DIAGNOSTIC_PUSH()
3508 // Suppress warning C4146 unary minus operator applied to unsigned type,
3509 // result still unsigned
3510 MY_COMPILER_MSVC_DIAGNOSTIC_IGNORE(4146)
3511 158 abs_dec = -static_cast<ulonglong>(dec);
3512 MY_COMPILER_DIAGNOSTIC_POP()
3513 longlong tmp;
3514
3515
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 148 times.
 158 if (abs_dec >= array_elements(log_10_int)) return 0;
3516
3517 148 tmp = log_10_int[abs_dec];
3518
3519
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 143 times.
 148 if (truncate)
3520
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
 5 return (unsigned_flag) ? ((ulonglong)value / tmp) * tmp
3521 5 : (value / tmp) * tmp;
3522
4/4
✓ Branch 0 taken 83 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 24 times.
✓ Branch 3 taken 59 times.
 143 else if (unsigned_flag || value >= 0) {
3523 84 bool round_overflow = false;
3524 ulonglong rounded_value =
3525 84 my_unsigned_round(static_cast<ulonglong>(value), tmp, &round_overflow);
3526
4/4
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 14 times.
 84 if (!unsigned_flag && rounded_value > LLONG_MAX)
3527
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
 10 return raise_integer_overflow();
3528
3/4
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
 74 if (round_overflow) return raise_integer_overflow();
3529 65 return rounded_value;
3530 } else {
3531 // We round "towards nearest", so
3532 // -9223372036854775808 should round to
3533 // -9223372036854775810 which underflows, or
3534 // -9223372036854775800 which is OK, or
3535 // -9223372036854776000 which underflows, and so on ...
3536
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 39 times.
 59 if (value == LLONG_MIN) {
3537
2/3
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 9 times.
 20 switch (abs_dec) {
3538 ✗ case 0:
3539 ✗ return LLONG_MIN;
3540 11 case 1:
3541 case 3:
3542 case 4:
3543 case 5:
3544 case 6:
3545 case 8:
3546 case 9:
3547 case 10:
3548 case 14:
3549 case 19:
3550
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 return raise_integer_overflow();
3551 9 default:
3552 9 return (LLONG_MIN / tmp) * tmp;
3553 }
3554 }
3555 39 bool not_used = false;
3556 ulonglong rounded_value =
3557 39 my_unsigned_round(static_cast<ulonglong>(-value), tmp, &not_used);
3558
3/4
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 29 times.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
 39 if (rounded_value > LLONG_MAX) return raise_integer_overflow();
3559
3560 29 return -static_cast<longlong>(rounded_value);
3561 }
3562 }
3563
3564 4079 my_decimal *Item_func_round::decimal_op(my_decimal *decimal_value) {
3565
1/2
✓ Branch 0 taken 4079 times.
✗ Branch 1 not taken.
 4079 my_decimal val, *value = args[0]->val_decimal(&val);
3566
1/2
✓ Branch 0 taken 4079 times.
✗ Branch 1 not taken.
 4079 longlong dec = args[1]->val_int();
3567
4/4
✓ Branch 0 taken 39 times.
✓ Branch 1 taken 4040 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 35 times.
 4079 if (dec >= 0 || args[1]->unsigned_flag)
3568 4044 dec = min<ulonglong>(dec, decimals);
3569
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 29 times.
 35 else if (dec < INT_MIN)
3570 6 dec = INT_MIN;
3571
3572
6/6
✓ Branch 0 taken 3751 times.
✓ Branch 1 taken 328 times.
✓ Branch 2 taken 3750 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 3750 times.
✓ Branch 5 taken 329 times.
 7829 if (!(null_value = (args[0]->null_value || args[1]->null_value ||
3573
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3750 times.
 3750 my_decimal_round(E_DEC_FATAL_ERROR, value, (int)dec,
3574
1/2
✓ Branch 0 taken 3750 times.
✗ Branch 1 not taken.
 3750 truncate, decimal_value) > 1)))
3575 3750 return decimal_value;
3576 329 return nullptr;
3577 4079 }
3578
3579 117970 bool Item_func_rand::itemize(Parse_context *pc, Item **res) {
3580
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 117971 times.
 117970 if (skip_itemize(res)) return false;
3581
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 117970 times.
 117971 if (super::itemize(pc, res)) return true;
3582 /*
3583 When RAND() is binlogged, the seed is binlogged too. So the
3584 sequence of random numbers is the same on a replication slave as
3585 on the master. However, if several RAND() values are inserted
3586 into a table, the order in which the rows are modified may differ
3587 between master and slave, because the order is undefined. Hence,
3588 the statement is unsafe to log in statement format.
3589 */
3590 117970 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
3591
3592 117971 pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_RAND);
3593 117971 return false;
3594 }
3595
3596 40957 void Item_func_rand::seed_random(Item *arg) {
3597 /*
3598 TODO: do not do reinit 'rand' for every execute of PS/SP if
3599 args[0] is a constant.
3600 */
3601 40957 uint32 tmp = (uint32)arg->val_int();
3602 40957 randominit(m_rand, (uint32)(tmp * 0x10001L + 55555555L),
3603 (uint32)(tmp * 0x10000001L));
3604 40957 }
3605
3606 117264 bool Item_func_rand::resolve_type(THD *thd) {
3607
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 117264 times.
 117264 if (param_type_is_default(thd, 0, -1, MYSQL_TYPE_DOUBLE)) return true;
3608
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 117264 times.
 117264 if (Item_real_func::resolve_type(thd)) return true;
3609 117264 return reject_geometry_args(arg_count, args, this);
3610 }
3611
3612 117265 bool Item_func_rand::fix_fields(THD *thd, Item **ref) {
3613
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 117263 times.
 117265 if (Item_real_func::fix_fields(thd, ref)) return true;
3614
3615
2/2
✓ Branch 0 taken 40958 times.
✓ Branch 1 taken 76305 times.
 117263 if (arg_count > 0) { // Only use argument once in query
3616 /*
3617 Allocate rand structure once: we must use thd->stmt_arena
3618 to create rand in proper mem_root if it's a prepared statement or
3619 stored procedure.
3620
3621 No need to send a Rand log event if seed was given eg: RAND(seed),
3622 as it will be replicated in the query as such.
3623 */
3624
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40958 times.
 40958 assert(m_rand == nullptr);
3625 40958 m_rand = pointer_cast<rand_struct *>(thd->alloc(sizeof(*m_rand)));
3626
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40958 times.
 40958 if (m_rand == nullptr) return true;
3627 } else {
3628 /*
3629 Save the seed only the first time RAND() is used in the query
3630 Once events are forwarded rather than recreated,
3631 the following can be skipped if inside the slave thread
3632 */
3633
2/2
✓ Branch 0 taken 69331 times.
✓ Branch 1 taken 6974 times.
 76305 if (!thd->rand_used) {
3634 69331 thd->rand_used = true;
3635 69331 thd->rand_saved_seed1 = thd->rand.seed1;
3636 69331 thd->rand_saved_seed2 = thd->rand.seed2;
3637 }
3638 }
3639 117263 return false;
3640 }
3641
3642 2165988 double Item_func_rand::val_real() {
3643
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2165988 times.
 2165988 assert(fixed);
3644 rand_struct *rand;
3645
2/2
✓ Branch 0 taken 532124 times.
✓ Branch 1 taken 1633864 times.
 2165988 if (arg_count > 0) {
3646
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 532108 times.
 532124 if (!args[0]->const_for_execution())
3647 16 seed_random(args[0]);
3648
2/2
✓ Branch 0 taken 40941 times.
✓ Branch 1 taken 491167 times.
 532108 else if (first_eval) {
3649 /*
3650 Constantness of args[0] may be set during JOIN::optimize(), if arg[0]
3651 is a field item of "constant" table. Thus, we have to evaluate
3652 seed_random() for constant arg there but not at the fix_fields method.
3653 */
3654 40941 first_eval = false;
3655 40941 seed_random(args[0]);
3656 }
3657 532124 rand = m_rand;
3658 } else {
3659 /*
3660 Save the seed only the first time RAND() is used in the query
3661 Once events are forwarded rather than recreated,
3662 the following can be skipped if inside the slave thread
3663 */
3664 1633864 THD *const thd = current_thd;
3665
2/2
✓ Branch 0 taken 628822 times.
✓ Branch 1 taken 1005113 times.
 1633935 if (!thd->rand_used) {
3666 628822 thd->rand_used = true;
3667 628822 thd->rand_saved_seed1 = thd->rand.seed1;
3668 628822 thd->rand_saved_seed2 = thd->rand.seed2;
3669 }
3670 1633935 rand = &thd->rand;
3671 }
3672 2166059 return my_rnd(rand);
3673 }
3674
3675 27 bool Item_func_sign::resolve_type(THD *thd) {
3676
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
 27 if (param_type_is_default(thd, 0, 1, MYSQL_TYPE_DOUBLE)) return true;
3677
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
 27 if (Item_int_func::resolve_type(thd)) return true;
3678 27 return reject_geometry_args(arg_count, args, this);
3679 }
3680
3681 34 longlong Item_func_sign::val_int() {
3682
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
 34 assert(fixed == 1);
3683 34 double value = args[0]->val_real();
3684 34 null_value = args[0]->null_value;
3685
4/4
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 19 times.
✓ Branch 3 taken 6 times.
 34 return value < 0.0 ? -1 : (value > 0 ? 1 : 0);
3686 }
3687
3688 37 bool Item_func_units::resolve_type(THD *thd) {
3689
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
 37 if (param_type_is_default(thd, 0, 1, MYSQL_TYPE_DOUBLE)) return true;
3690 37 decimals = DECIMAL_NOT_SPECIFIED;
3691 37 max_length = float_length(decimals);
3692 37 return reject_geometry_args(arg_count, args, this);
3693 }
3694
3695 35 double Item_func_units::val_real() {
3696
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 35 times.
 35 assert(fixed == 1);
3697 35 double value = args[0]->val_real();
3698
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 35 times.
 35 if ((null_value = args[0]->null_value)) return 0;
3699 35 return check_float_overflow(value * mul + add);
3700 }
3701
3702 3916 bool Item_func_min_max::resolve_type(THD *thd) {
3703 // If no arguments have type, type of this operator cannot be determined yet
3704
5/6
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3910 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 3910 times.
 3922 if (args[0]->data_type() == MYSQL_TYPE_INVALID &&
3705 6 args[1]->data_type() == MYSQL_TYPE_INVALID)
3706 6 return false;
3707
3708
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3909 times.
 3910 if (resolve_type_inner(thd)) return true;
3709 3909 return reject_geometry_args(arg_count, args, this);
3710 }
3711
3712 3916 bool Item_func_min_max::resolve_type_inner(THD *thd) {
3713
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3916 times.
 3916 if (param_type_uses_non_param(thd)) return true;
3714 3916 aggregate_type(make_array(args, arg_count));
3715 3916 hybrid_type = Field::result_merge_type(data_type());
3716
2/2
✓ Branch 0 taken 224 times.
✓ Branch 1 taken 3692 times.
 3916 if (hybrid_type == STRING_RESULT) {
3717 /*
3718 If one or more of the arguments have a temporal data type, temporal_item
3719 must be set for correct conversion from temporal values to various result
3720 types.
3721 */
3722
2/2
✓ Branch 0 taken 494 times.
✓ Branch 1 taken 224 times.
 718 for (uint i = 0; i < arg_count; i++) {
3723
2/2
✓ Branch 0 taken 241 times.
✓ Branch 1 taken 253 times.
 494 if (args[i]->is_temporal()) {
3724 /*
3725 If one of the arguments is DATETIME, overwrite any existing
3726 temporal_item since DATETIME contains both date and time and is the
3727 most general and detailed data type to which other temporal types can
3728 be converted without loss of information.
3729 */
3730
6/6
✓ Branch 0 taken 73 times.
✓ Branch 1 taken 168 times.
✓ Branch 2 taken 26 times.
✓ Branch 3 taken 47 times.
✓ Branch 4 taken 194 times.
✓ Branch 5 taken 47 times.
 241 if (!temporal_item || args[i]->data_type() == MYSQL_TYPE_DATETIME)
3731 194 temporal_item = args[i];
3732 }
3733 }
3734 /*
3735 If one or more, but not all, of the arguments have a temporal data type,
3736 the data type of this item must be set temporarily to ensure that the
3737 various aggregate functions derive the correct properties.
3738 */
3739
2/2
✓ Branch 0 taken 103 times.
✓ Branch 1 taken 56 times.
 383 enum_field_types tmp_data_type = (!is_temporal() && has_temporal_arg())
3740
2/2
✓ Branch 0 taken 159 times.
✓ Branch 1 taken 65 times.
 327 ? temporal_item->data_type()
3741 121 : data_type();
3742 224 enum_field_types aggregated_data_type = data_type();
3743 224 set_data_type(tmp_data_type);
3744
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 223 times.
 224 if (aggregate_string_properties(func_name(), args, arg_count)) return true;
3745 223 set_data_type(aggregated_data_type);
3746 } else
3747 3692 aggregate_num_type(hybrid_type, args, arg_count);
3748
3749 /*
3750 LEAST and GREATEST convert JSON values to strings before they are
3751 compared, so their JSON nature is lost. Raise a warning to
3752 indicate to the users that the values are not compared using the
3753 JSON comparator, as they might expect. Also update the field type
3754 of the result to reflect that the result is a string.
3755 */
3756 3915 unsupported_json_comparison(arg_count, args,
3757 "comparison of JSON in the "
3758 "LEAST and GREATEST operators");
3759
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3915 times.
 3915 if (data_type() == MYSQL_TYPE_JSON) set_data_type(MYSQL_TYPE_VARCHAR);
3760 3915 return false;
3761 }
3762
3763 209 bool Item_func_min_max::cmp_datetimes(longlong *value) {
3764 209 THD *thd = current_thd;
3765 209 longlong res = 0;
3766
2/2
✓ Branch 0 taken 430 times.
✓ Branch 1 taken 192 times.
 622 for (uint i = 0; i < arg_count; i++) {
3767 430 Item **arg = args + i;
3768 bool is_null;
3769 longlong tmp =
3770
1/2
✓ Branch 0 taken 430 times.
✗ Branch 1 not taken.
 430 get_datetime_value(thd, &arg, nullptr, temporal_item, &is_null);
3771
3772 // Check if we need to stop (because of error or KILL) and stop the loop
3773
3/4
✓ Branch 0 taken 430 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 429 times.
 446 if ((null_value = thd->is_error())) return true;
3774
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 413 times.
 429 if ((null_value = args[i]->null_value)) return true;
3775
4/4
✓ Branch 0 taken 221 times.
✓ Branch 1 taken 192 times.
✓ Branch 2 taken 89 times.
✓ Branch 3 taken 132 times.
 413 if (i == 0 || (tmp < res) == m_is_least_func) res = tmp;
3776 }
3777 192 *value = res;
3778 192 return false;
3779 }
3780
3781 10 bool Item_func_min_max::cmp_times(longlong *value) {
3782 10 longlong res = 0;
3783
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 8 times.
 28 for (uint i = 0; i < arg_count; i++) {
3784 20 longlong tmp = args[i]->val_time_temporal();
3785
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 18 times.
 20 if ((null_value = args[i]->null_value)) return true;
3786
4/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 4 times.
 18 if (i == 0 || (tmp < res) == m_is_least_func) res = tmp;
3787 }
3788 8 *value = res;
3789 8 return false;
3790 }
3791
3792 172 String *Item_func_min_max::str_op(String *str) {
3793
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 172 times.
 172 assert(fixed);
3794 172 null_value = false;
3795
2/2
✓ Branch 0 taken 100 times.
✓ Branch 1 taken 72 times.
 172 if (compare_as_dates()) {
3796 100 longlong result = 0;
3797
4/6
✓ Branch 0 taken 100 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 89 times.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
 180 if (cmp_datetimes(&result)) return error_str();
3798
3799 /*
3800 If result is greater than 0, the winning argument was successfully
3801 converted to a time value and should be converted to a string
3802 formatted in accordance with the data type in temporal_item. Otherwise,
3803 the arguments should be compared based on their raw string value.
3804 */
3805
2/2
✓ Branch 0 taken 80 times.
✓ Branch 1 taken 9 times.
 89 if (result > 0) {
3806 MYSQL_TIME ltime;
3807 80 enum_field_types field_type = temporal_item->data_type();
3808
1/2
✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
 80 TIME_from_longlong_packed(&ltime, field_type, result);
3809
1/2
✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
 80 null_value = my_TIME_to_str(&ltime, str, decimals);
3810
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
 80 if (null_value) return nullptr;
3811
3/4
✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29 times.
✓ Branch 3 taken 51 times.
 80 if (str->needs_conversion(collation.collation)) {
3812 29 uint errors = 0;
3813 29 StringBuffer<STRING_BUFFER_USUAL_SIZE * 2> convert_string(nullptr);
3814 bool copy_failed =
3815
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 convert_string.copy(str->ptr(), str->length(), str->charset(),
3816 collation.collation, &errors);
3817
5/10
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 29 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 29 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 29 times.
 29 if (copy_failed || errors || str->copy(convert_string))
3818 ✗ return error_str();
3819
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 }
3820 80 return str;
3821 }
3822 }
3823
3824 // Find the least/greatest argument based on string value.
3825 81 String *res = nullptr;
3826 81 bool res_in_str = false;
3827
2/2
✓ Branch 0 taken 171 times.
✓ Branch 1 taken 71 times.
 242 for (uint i = 0; i < arg_count; i++) {
3828 /*
3829 Because val_str() may reallocate the underlying buffer of its String
3830 parameter, it is paramount the passed String argument do not share an
3831 underlying buffer with the currently stored result against which it will
3832 be compared to ensure that String comparison operates on two
3833 non-overlapping buffers.
3834 */
3835
2/2
✓ Branch 0 taken 82 times.
✓ Branch 1 taken 89 times.
 171 String *val_buf = res_in_str ? &m_string_buf : str;
3836
4/6
✓ Branch 0 taken 90 times.
✓ Branch 1 taken 81 times.
✓ Branch 2 taken 90 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 90 times.
✗ Branch 5 not taken.
 171 assert(!res || (res != val_buf && !res->uses_buffer_owned_by(val_buf)));
3837 171 String *val = args[i]->val_str(val_buf);
3838
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 161 times.
 171 if ((null_value = args[i]->null_value)) return nullptr;
3839
4/4
✓ Branch 0 taken 85 times.
✓ Branch 1 taken 76 times.
✓ Branch 2 taken 106 times.
✓ Branch 3 taken 55 times.
 246 if (i == 0 ||
3840
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 55 times.
 85 (sortcmp(val, res, collation.collation) < 0) == m_is_least_func) {
3841 106 res = val;
3842 106 res_in_str = !res_in_str;
3843 }
3844 }
3845 71 res->set_charset(collation.collation);
3846 71 return res;
3847 }
3848
3849 85 bool Item_func_min_max::date_op(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) {
3850
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
 85 assert(fixed == 1);
3851 85 longlong result = 0;
3852
3/4
✓ Branch 0 taken 85 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 80 times.
 85 if (cmp_datetimes(&result)) return true;
3853
1/2
✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
 80 TIME_from_longlong_packed(ltime, data_type(), result);
3854 int warnings;
3855
1/2
✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
 80 return check_date(*ltime, non_zero_date(*ltime), fuzzydate, &warnings);
3856 }
3857
3858 10 bool Item_func_min_max::time_op(MYSQL_TIME *ltime) {
3859
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 assert(fixed == 1);
3860 10 longlong result = 0;
3861
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (compare_as_dates()) {
3862 ✗ if (cmp_datetimes(&result)) return true;
3863 ✗ TIME_from_longlong_packed(ltime, data_type(), result);
3864 ✗ datetime_to_time(ltime);
3865 ✗ return false;
3866 }
3867
3868
3/4
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
 10 if (cmp_times(&result)) return true;
3869
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 TIME_from_longlong_time_packed(ltime, result);
3870 8 return false;
3871 }
3872
3873 27 double Item_func_min_max::real_op() {
3874
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
 27 assert(fixed == 1);
3875 27 null_value = false;
3876
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 13 times.
 27 if (compare_as_dates()) {
3877 14 longlong result = 0;
3878
3/4
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 13 times.
 14 if (cmp_datetimes(&result)) return 0;
3879
1/2
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
 13 return double_from_datetime_packed(temporal_item->data_type(), result);
3880 }
3881
3882 // Find the least/greatest argument based on double value.
3883 13 double result = 0.0;
3884
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 11 times.
 38 for (uint i = 0; i < arg_count; i++) {
3885 27 const double tmp = args[i]->val_real();
3886
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 25 times.
 27 if ((null_value = args[i]->null_value)) return 0.0;
3887
4/4
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 6 times.
 25 if (i == 0 || (tmp < result) == m_is_least_func) result = tmp;
3888 }
3889 11 return result;
3890 }
3891
3892 13772 longlong Item_func_min_max::int_op() {
3893
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13772 times.
 13772 assert(fixed);
3894 13772 null_value = false;
3895 13772 longlong res = 0;
3896
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 13767 times.
 13772 if (compare_as_dates()) {
3897
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
 5 if (cmp_datetimes(&res)) return 0;
3898
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 return longlong_from_datetime_packed(temporal_item->data_type(), res);
3899 }
3900
3901 // Find the least/greatest argument based on integer value.
3902
2/2
✓ Branch 0 taken 26129 times.
✓ Branch 1 taken 9410 times.
 35539 for (uint i = 0; i < arg_count; i++) {
3903
1/2
✓ Branch 0 taken 26129 times.
✗ Branch 1 not taken.
 26129 const longlong val = args[i]->val_int();
3904
2/2
✓ Branch 0 taken 4357 times.
✓ Branch 1 taken 21772 times.
 26129 if ((null_value = args[i]->null_value)) return 0;
3905 #ifndef NDEBUG
3906 21772 Integer_value arg_val(val, args[i]->unsigned_flag);
3907
3/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 21756 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
 21772 assert(!unsigned_flag || !arg_val.is_negative());
3908 #endif
3909
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 21756 times.
 21772 const bool val_is_smaller = unsigned_flag ? static_cast<ulonglong>(val) <
3910 16 static_cast<ulonglong>(res)
3911 21756 : val < res;
3912
4/4
✓ Branch 0 taken 12358 times.
✓ Branch 1 taken 9414 times.
✓ Branch 2 taken 2921 times.
✓ Branch 3 taken 9437 times.
 21772 if (i == 0 || val_is_smaller == m_is_least_func) res = val;
3913 }
3914 9410 return res;
3915 }
3916
3917 34 my_decimal *Item_func_min_max::decimal_op(my_decimal *dec) {
3918
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
 34 assert(fixed == 1);
3919 34 null_value = false;
3920
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 29 times.
 34 if (compare_as_dates()) {
3921 5 longlong result = 0;
3922
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
 5 if (cmp_datetimes(&result)) return nullptr;
3923
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 return my_decimal_from_datetime_packed(dec, temporal_item->data_type(),
3924 5 result);
3925 }
3926
3927 // Find the least/greatest argument based on decimal value.
3928
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 my_decimal tmp_buf, *res = args[0]->val_decimal(dec);
3929
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 28 times.
 91 for (uint i = 0; i < arg_count; i++) {
3930
3/4
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 34 times.
✓ Branch 2 taken 63 times.
✗ Branch 3 not taken.
 63 my_decimal *tmp = args[i]->val_decimal(res == dec ? &tmp_buf : dec);
3931
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 62 times.
 63 if ((null_value = args[i]->null_value)) return nullptr;
3932
7/8
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 29 times.
✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 17 times.
✓ Branch 5 taken 16 times.
✓ Branch 6 taken 46 times.
✓ Branch 7 taken 16 times.
 62 if (i == 0 || (my_decimal_cmp(tmp, res) < 0) == m_is_least_func) res = tmp;
3933 }
3934 // Result must me copied from temporary buffer to remain valid after return.
3935
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 17 times.
 28 if (res == &tmp_buf) {
3936
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 my_decimal2decimal(res, dec);
3937 11 res = dec;
3938 }
3939 28 return res;
3940 29 }
3941
3942 33 double Item_func_min_max::val_real() {
3943
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33 times.
 33 assert(fixed == 1);
3944
6/6
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 14 times.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 18 times.
✓ Branch 5 taken 15 times.
 33 if (has_temporal_arg() && data_type() == MYSQL_TYPE_VARCHAR)
3945 18 return real_op(); // For correct conversion from temporal value to string.
3946 15 return Item_func_numhybrid::val_real();
3947 }
3948
3949 13748 longlong Item_func_min_max::val_int() {
3950
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13748 times.
 13748 assert(fixed == 1);
3951
5/6
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 13743 times.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 13743 times.
 13748 if (has_temporal_arg() && data_type() == MYSQL_TYPE_VARCHAR)
3952 5 return int_op(); // For correct conversion from temporal value to int.
3953 13743 return Item_func_numhybrid::val_int();
3954 }
3955
3956 33 my_decimal *Item_func_min_max::val_decimal(my_decimal *dec) {
3957
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33 times.
 33 assert(fixed == 1);
3958
6/6
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 28 times.
 33 if (has_temporal_arg() && data_type() == MYSQL_TYPE_VARCHAR)
3959 5 return decimal_op(
3960 5 dec); // For correct conversion from temporal value to dec
3961 28 return Item_func_numhybrid::val_decimal(dec);
3962 }
3963
3964 13 bool Item_rollup_group_item::get_date(MYSQL_TIME *ltime,
3965 my_time_flags_t fuzzydate) {
3966
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
 13 assert(fixed);
3967
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 11 times.
 13 if (rollup_null()) {
3968 2 null_value = true;
3969 2 return true;
3970 }
3971 11 return (null_value = args[0]->get_date(ltime, fuzzydate));
3972 }
3973
3974 5 bool Item_rollup_group_item::get_time(MYSQL_TIME *ltime) {
3975
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 assert(fixed);
3976
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 4 times.
 5 if (rollup_null()) {
3977 1 null_value = true;
3978 1 return true;
3979 }
3980 4 return (null_value = args[0]->get_time(ltime));
3981 }
3982
3983 323 double Item_rollup_group_item::val_real() {
3984
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 323 times.
 323 assert(fixed);
3985
2/2
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 255 times.
 323 if (rollup_null()) {
3986 68 null_value = true;
3987 68 return 0.0;
3988 }
3989 255 double res = args[0]->val_real();
3990
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 240 times.
 255 if ((null_value = args[0]->null_value)) return 0.0;
3991 240 return res;
3992 }
3993
3994 6319 longlong Item_rollup_group_item::val_int() {
3995
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6319 times.
 6319 assert(fixed);
3996
2/2
✓ Branch 0 taken 901 times.
✓ Branch 1 taken 5418 times.
 6319 if (rollup_null()) {
3997 901 null_value = true;
3998 901 return 0;
3999 }
4000 5418 longlong res = args[0]->val_int();
4001
2/2
✓ Branch 0 taken 96 times.
✓ Branch 1 taken 5322 times.
 5418 if ((null_value = args[0]->null_value)) return 0;
4002 5322 return res;
4003 }
4004
4005 1061 String *Item_rollup_group_item::val_str(String *str) {
4006
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1061 times.
 1061 assert(fixed);
4007
2/2
✓ Branch 0 taken 138 times.
✓ Branch 1 taken 923 times.
 1061 if (rollup_null()) {
4008 138 null_value = true;
4009 138 return nullptr;
4010 }
4011 923 String *res = args[0]->val_str(str);
4012
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 914 times.
 923 if ((null_value = args[0]->null_value)) return nullptr;
4013 914 return res;
4014 }
4015
4016 212 my_decimal *Item_rollup_group_item::val_decimal(my_decimal *dec) {
4017
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 212 times.
 212 assert(fixed);
4018
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 207 times.
 212 if (rollup_null()) {
4019 5 null_value = true;
4020 5 return nullptr;
4021 }
4022 207 my_decimal *res = args[0]->val_decimal(dec);
4023
2/2
✓ Branch 0 taken 39 times.
✓ Branch 1 taken 168 times.
 207 if ((null_value = args[0]->null_value)) return nullptr;
4024 168 return res;
4025 }
4026
4027 5 bool Item_rollup_group_item::val_json(Json_wrapper *result) {
4028
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 assert(fixed);
4029
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 4 times.
 5 if (rollup_null()) {
4030 1 null_value = true;
4031 1 return false;
4032 }
4033 4 bool res = args[0]->val_json(result);
4034 4 null_value = args[0]->null_value;
4035 4 return res;
4036 }
4037
4038 110 void Item_rollup_group_item::print(const THD *thd, String *str,
4039 enum_query_type query_type) const {
4040
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 106 times.
 110 if (query_type & QT_HIDE_ROLLUP_FUNCTIONS) {
4041
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 print_args(thd, str, 0, query_type);
4042 4 return;
4043 }
4044
4045
1/2
✓ Branch 0 taken 106 times.
✗ Branch 1 not taken.
 106 str->append(func_name());
4046
1/2
✓ Branch 0 taken 106 times.
✗ Branch 1 not taken.
 106 str->append('(');
4047
1/2
✓ Branch 0 taken 106 times.
✗ Branch 1 not taken.
 106 print_args(thd, str, 0, query_type);
4048
1/2
✓ Branch 0 taken 106 times.
✗ Branch 1 not taken.
 106 str->append(',');
4049 char buf[16];
4050 106 snprintf(buf, sizeof(buf), "%d", m_min_rollup_level);
4051
1/2
✓ Branch 0 taken 106 times.
✗ Branch 1 not taken.
 106 str->append(buf);
4052
1/2
✓ Branch 0 taken 106 times.
✗ Branch 1 not taken.
 106 str->append(')');
4053 }
4054
4055 209 bool Item_rollup_group_item::eq(const Item *item, bool binary_cmp) const {
4056
4/4
✓ Branch 0 taken 127 times.
✓ Branch 1 taken 82 times.
✓ Branch 2 taken 126 times.
✓ Branch 3 taken 1 times.
 336 return Item_func::eq(item, binary_cmp) &&
4057 127 min_rollup_level() == down_cast<const Item_rollup_group_item *>(item)
4058 336 ->min_rollup_level();
4059 }
4060
4061 19332052 longlong Item_func_length::val_int() {
4062
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19332052 times.
 19332052 assert(fixed == 1);
4063 19332052 String *res = args[0]->val_str(&value);
4064
2/2
✓ Branch 0 taken 16201693 times.
✓ Branch 1 taken 3130359 times.
 19332052 if (!res) {
4065 16201693 null_value = true;
4066 16201693 return 0; /* purecov: inspected */
4067 }
4068 3130359 null_value = false;
4069 3130359 return (longlong)res->length();
4070 }
4071
4072 780301 longlong Item_func_char_length::val_int() {
4073
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 780301 times.
 780301 assert(fixed == 1);
4074 780301 String *res = args[0]->val_str(&value);
4075
2/2
✓ Branch 0 taken 83 times.
✓ Branch 1 taken 780218 times.
 780301 if (!res) {
4076 83 null_value = true;
4077 83 return 0; /* purecov: inspected */
4078 }
4079 780218 null_value = false;
4080 780218 return (longlong)res->numchars();
4081 }
4082
4083 114 longlong Item_func_coercibility::val_int() {
4084
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 114 times.
 114 assert(fixed == 1);
4085 114 null_value = false;
4086 114 return (longlong)args[0]->collation.derivation;
4087 }
4088
4089 445723 bool Item_func_locate::resolve_type(THD *thd) {
4090
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 445723 times.
 445723 if (param_type_is_default(thd, 0, 2)) return true;
4091
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 445723 times.
 445723 if (param_type_is_default(thd, 2, 3, MYSQL_TYPE_LONGLONG)) return true;
4092 445723 max_length = MY_INT32_NUM_DECIMAL_DIGITS;
4093
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 445723 times.
 445723 if (agg_arg_charsets_for_string_result(collation, args, 1)) return true;
4094
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 445723 times.
 445723 if (simplify_string_args(thd, collation, args + 1, 1)) return true;
4095 445723 return false;
4096 }
4097
4098 693944 longlong Item_func_locate::val_int() {
4099
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 693944 times.
 693944 assert(fixed);
4100 // Evaluate the string argument first
4101 693944 const CHARSET_INFO *cs = collation.collation;
4102
1/2
✓ Branch 0 taken 693944 times.
✗ Branch 1 not taken.
 693944 String *a = eval_string_arg(cs, args[0], &value1);
4103
2/2
✓ Branch 0 taken 149 times.
✓ Branch 1 taken 693795 times.
 693944 if (a == nullptr) return error_int();
4104
4105 // Evaluate substring argument in same character set as string argument
4106
1/2
✓ Branch 0 taken 693795 times.
✗ Branch 1 not taken.
 693795 String *b = eval_string_arg(cs, args[1], &value2);
4107
2/2
✓ Branch 0 taken 55 times.
✓ Branch 1 taken 693740 times.
 693795 if (b == nullptr) return error_int();
4108
4109 693740 null_value = false;
4110 /* must be longlong to avoid truncation */
4111 693740 longlong start = 0;
4112 693740 longlong start0 = 0;
4113 my_match_t match;
4114
4115
2/2
✓ Branch 0 taken 31259 times.
✓ Branch 1 taken 662481 times.
 693740 if (arg_count == 3) {
4116
1/2
✓ Branch 0 taken 31259 times.
✗ Branch 1 not taken.
 31259 const longlong tmp = args[2]->val_int();
4117
6/6
✓ Branch 0 taken 31240 times.
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 62 times.
✓ Branch 3 taken 31178 times.
✓ Branch 4 taken 81 times.
✓ Branch 5 taken 31178 times.
 31259 if ((null_value = args[2]->null_value) || tmp <= 0) return 0;
4118 31178 start0 = start = tmp - 1;
4119
4120
2/2
✓ Branch 0 taken 431 times.
✓ Branch 1 taken 30747 times.
 31178 if (start > static_cast<longlong>(a->length())) return 0;
4121
4122 /* start is now sufficiently valid to pass to charpos function */
4123
1/2
✓ Branch 0 taken 30747 times.
✗ Branch 1 not taken.
 30747 start = a->charpos((int)start);
4124
4125
2/2
✓ Branch 0 taken 728 times.
✓ Branch 1 taken 30019 times.
 30747 if (start + b->length() > a->length()) return 0;
4126 }
4127
4128
2/2
✓ Branch 0 taken 46 times.
✓ Branch 1 taken 692454 times.
 692500 if (!b->length()) // Found empty string at start
4129 46 return start + 1;
4130
4131
3/4
✓ Branch 0 taken 692454 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 310648 times.
✓ Branch 3 taken 381806 times.
 1384908 if (!cs->coll->strstr(cs, a->ptr() + start,
4132 692454 static_cast<uint>(a->length() - start), b->ptr(),
4133 b->length(), &match, 1))
4134 310648 return 0;
4135 381806 return static_cast<longlong>(match.mb_len) + start0 + 1;
4136 }
4137
4138 41408 void Item_func_locate::print(const THD *thd, String *str,
4139 enum_query_type query_type) const {
4140 41408 str->append(STRING_WITH_LEN("locate("));
4141 41408 args[1]->print(thd, str, query_type);
4142 41408 str->append(',');
4143 41408 args[0]->print(thd, str, query_type);
4144
2/2
✓ Branch 0 taken 981 times.
✓ Branch 1 taken 40427 times.
 41408 if (arg_count == 3) {
4145 981 str->append(',');
4146 981 args[2]->print(thd, str, query_type);
4147 }
4148 41408 str->append(')');
4149 41408 }
4150
4151 43 longlong Item_func_validate_password_strength::val_int() {
4152 char buff[STRING_BUFFER_USUAL_SIZE];
4153 43 String value(buff, sizeof(buff), system_charset_info);
4154
1/2
✓ Branch 0 taken 43 times.
✗ Branch 1 not taken.
 43 String *field = args[0]->val_str(&value);
4155
6/6
✓ Branch 0 taken 41 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 38 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 38 times.
 43 if ((null_value = args[0]->null_value) || field->length() == 0) return 0;
4156
1/2
✓ Branch 0 taken 38 times.
✗ Branch 1 not taken.
 38 return (my_calculate_password_strength(field->ptr(), field->length()));
4157 43 }
4158
4159 133 longlong Item_func_field::val_int() {
4160
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 133 times.
 133 assert(fixed);
4161
4162
2/2
✓ Branch 0 taken 111 times.
✓ Branch 1 taken 22 times.
 133 if (cmp_type == STRING_RESULT) {
4163 111 const CHARSET_INFO *cs = collation.collation;
4164 111 String *field = eval_string_arg(cs, args[0], &value);
4165
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 106 times.
 111 if (field == nullptr) return 0;
4166
2/2
✓ Branch 0 taken 199 times.
✓ Branch 1 taken 7 times.
 206 for (uint i = 1; i < arg_count; i++) {
4167 199 String *tmp_value = eval_string_arg(cs, args[i], &tmp);
4168
6/6
✓ Branch 0 taken 194 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 99 times.
✓ Branch 3 taken 95 times.
✓ Branch 4 taken 99 times.
✓ Branch 5 taken 100 times.
 199 if (tmp_value != nullptr && !sortcmp(field, tmp_value, cs)) {
4169 99 return i;
4170 }
4171 }
4172
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 16 times.
 22 } else if (cmp_type == INT_RESULT) {
4173 6 longlong val = args[0]->val_int();
4174
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (args[0]->null_value) return 0;
4175
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 5 times.
 11 for (uint i = 1; i < arg_count; i++) {
4176
5/6
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 5 times.
 6 if (val == args[i]->val_int() && !args[i]->null_value) {
4177 1 return i;
4178 }
4179 }
4180
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 } else if (cmp_type == DECIMAL_RESULT) {
4181 ✗ my_decimal dec_arg_buf, *dec_arg, dec_buf,
4182 ✗ *dec = args[0]->val_decimal(&dec_buf);
4183 ✗ if (args[0]->null_value) return 0;
4184 ✗ for (uint i = 1; i < arg_count; i++) {
4185 ✗ dec_arg = args[i]->val_decimal(&dec_arg_buf);
4186 ✗ if (!args[i]->null_value && !my_decimal_cmp(dec_arg, dec)) {
4187 ✗ return i;
4188 }
4189 }
4190 ✗ } else {
4191 16 double val = args[0]->val_real();
4192
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 11 times.
 16 if (args[0]->null_value) return 0;
4193
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 6 times.
 30 for (uint i = 1; i < arg_count; i++) {
4194
6/6
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 19 times.
 24 if (val == args[i]->val_real() && !args[i]->null_value) {
4195 5 return i;
4196 }
4197 }
4198 }
4199 18 return 0;
4200 }
4201
4202 73 bool Item_func_field::resolve_type(THD *thd) {
4203
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
 73 if (Item_int_func::resolve_type(thd)) return true;
4204 73 set_nullable(false);
4205 73 max_length = 3;
4206 73 cmp_type = args[0]->result_type();
4207
2/2
✓ Branch 0 taken 257 times.
✓ Branch 1 taken 73 times.
 330 for (uint i = 1; i < arg_count; i++)
4208 257 cmp_type = item_cmp_type(cmp_type, args[i]->result_type());
4209
2/2
✓ Branch 0 taken 56 times.
✓ Branch 1 taken 17 times.
 73 if (cmp_type == STRING_RESULT) {
4210
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 56 times.
 56 if (agg_arg_charsets_for_string_result(collation, args, 1)) return true;
4211
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 56 times.
 56 if (simplify_string_args(thd, collation, args + 1, arg_count - 1))
4212 ✗ return true;
4213 }
4214 73 return false;
4215 }
4216
4217 52054 longlong Item_func_ascii::val_int() {
4218
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 52054 times.
 52054 assert(fixed == 1);
4219 52054 String *res = args[0]->val_str(&value);
4220
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 52052 times.
 52054 if (!res) {
4221 2 null_value = true;
4222 2 return 0;
4223 }
4224 52052 null_value = false;
4225
2/2
✓ Branch 0 taken 52050 times.
✓ Branch 1 taken 2 times.
 52052 return (longlong)(res->length() ? (uchar)(*res)[0] : (uchar)0);
4226 }
4227
4228 656429 longlong Item_func_ord::val_int() {
4229
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 656429 times.
 656429 assert(fixed == 1);
4230 656429 String *res = args[0]->val_str(&value);
4231
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 656429 times.
 656429 if (!res) {
4232 ✗ null_value = true;
4233 ✗ return 0;
4234 }
4235 656429 null_value = false;
4236
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 656429 times.
 656429 if (!res->length()) return 0;
4237
2/2
✓ Branch 0 taken 611942 times.
✓ Branch 1 taken 44487 times.
 656429 if (use_mb(res->charset())) {
4238 611942 const char *str = res->ptr();
4239 611942 uint32 n = 0, l = my_ismbchar(res->charset(), str, str + res->length());
4240
2/2
✓ Branch 0 taken 17046 times.
✓ Branch 1 taken 594896 times.
 611942 if (!l) return (longlong)((uchar)*str);
4241
2/2
✓ Branch 0 taken 1251290 times.
✓ Branch 1 taken 594896 times.
 1846186 while (l--) n = (n << 8) | (uint32)((uchar)*str++);
4242 594896 return (longlong)n;
4243 }
4244 44487 return (longlong)((uchar)(*res)[0]);
4245 }
4246
4247 /* Search after a string in a string of strings separated by ',' */
4248 /* Returns number of found type >= 1 or 0 if not found */
4249 /* This optimizes searching in enums to bit testing! */
4250
4251 4356 bool Item_func_find_in_set::resolve_type(THD *thd) {
4252
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4356 times.
 4356 if (param_type_is_default(thd, 0, -1)) return true;
4253 4356 max_length = 3; // 1-999
4254
4255
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4354 times.
 4356 if (agg_arg_charsets_for_comparison(cmp_collation, args, 2)) {
4256 2 return true;
4257 }
4258
6/6
✓ Branch 0 taken 4078 times.
✓ Branch 1 taken 276 times.
✓ Branch 2 taken 3192 times.
✓ Branch 3 taken 886 times.
✓ Branch 4 taken 3190 times.
✓ Branch 5 taken 1164 times.
 7546 if (args[0]->const_item() && args[1]->type() == FIELD_ITEM &&
4259
2/2
✓ Branch 0 taken 3190 times.
✓ Branch 1 taken 2 times.
 3192 args[0]->may_eval_const_item(thd)) {
4260 3190 Field *field = down_cast<Item_field *>(args[1])->field;
4261
2/2
✓ Branch 0 taken 3185 times.
✓ Branch 1 taken 5 times.
 3190 if (field->real_type() == MYSQL_TYPE_SET) {
4262 3185 String *find = args[0]->val_str(&value);
4263
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3185 times.
 3185 if (thd->is_error()) return true;
4264
2/2
✓ Branch 0 taken 3183 times.
✓ Branch 1 taken 2 times.
 3185 if (find != nullptr) {
4265 // find is not NULL pointer so args[0] is not a null-value
4266
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3183 times.
 3183 assert(!args[0]->null_value);
4267 6366 m_enum_value = find_type(down_cast<Field_enum *>(field)->typelib,
4268 3183 find->ptr(), find->length(), false);
4269 }
4270 }
4271 }
4272 4354 return false;
4273 }
4274
4275 static const char separator = ',';
4276
4277 4529 longlong Item_func_find_in_set::val_int() {
4278
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4529 times.
 4529 assert(fixed);
4279
4280 4529 null_value = false;
4281
4282
2/2
✓ Branch 0 taken 380 times.
✓ Branch 1 taken 4149 times.
 4529 if (m_enum_value != 0) {
4283 // enum_value is set iff args[0]->const_item() in resolve_type().
4284
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 380 times.
 380 assert(args[0]->const_item());
4285
4286 380 ulonglong tmp = static_cast<ulonglong>(args[1]->val_int());
4287
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 379 times.
 380 if (args[1]->null_value) return error_int();
4288 /*
4289 No need to check args[0]->null_value since enum_value is set iff
4290 args[0] is a non-null const item. Note: no assert on
4291 args[0]->null_value here because args[0] may have been replaced
4292 by an Item_cache on which val_int() has not been called. See
4293 BUG#11766317
4294 */
4295
2/2
✓ Branch 0 taken 70 times.
✓ Branch 1 taken 309 times.
 379 return (tmp & (1ULL << (m_enum_value - 1))) ? m_enum_value : 0;
4296 }
4297
4298 4149 String *find = args[0]->val_str(&value);
4299
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 4129 times.
 4149 if (find == nullptr) return error_int();
4300
4301
4/4
✓ Branch 0 taken 551 times.
✓ Branch 1 taken 3578 times.
✓ Branch 2 taken 55 times.
✓ Branch 3 taken 4074 times.
 4680 if (args[1]->type() == FIELD_ITEM &&
4302
2/2
✓ Branch 0 taken 55 times.
✓ Branch 1 taken 496 times.
 551 down_cast<Item_field *>(args[1])->field->real_type() == MYSQL_TYPE_SET) {
4303 55 Field *field = down_cast<Item_field *>(args[1])->field;
4304
4305 55 ulonglong tmp = static_cast<ulonglong>(args[1]->val_int());
4306
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 52 times.
 55 if (args[1]->null_value) return error_int();
4307
4308 52 uint value = find_type(down_cast<Field_enum *>(field)->typelib, find->ptr(),
4309 find->length(), false);
4310
4/4
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 42 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 2 times.
 52 return (value != 0 && (tmp & (1ULL << (value - 1)))) ? value : 0;
4311 }
4312
4313 4074 String *buffer = args[1]->val_str(&value2);
4314
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4072 times.
 4074 if (buffer == nullptr) return error_int();
4315
4316
2/2
✓ Branch 0 taken 3814 times.
✓ Branch 1 taken 258 times.
 4072 if (buffer->length() >= find->length()) {
4317 3814 my_wc_t wc = 0;
4318 3814 const CHARSET_INFO *cs = cmp_collation.collation;
4319 3814 const char *str_begin = buffer->ptr();
4320 3814 const char *str_end = buffer->ptr();
4321 3814 const char *real_end = str_end + buffer->length();
4322 3814 const uchar *find_str = (const uchar *)find->ptr();
4323 3814 size_t find_str_len = find->length();
4324 3814 int position = 0;
4325 while (true) {
4326 int symbol_len;
4327 64005 if ((symbol_len =
4328
1/2
✓ Branch 0 taken 64005 times.
✗ Branch 1 not taken.
 64005 cs->cset->mb_wc(cs, &wc, pointer_cast<const uchar *>(str_end),
4329
2/2
✓ Branch 0 taken 61319 times.
✓ Branch 1 taken 2686 times.
 64005 pointer_cast<const uchar *>(real_end))) > 0) {
4330 61319 const char *substr_end = str_end + symbol_len;
4331 61319 bool is_last_item = (substr_end == real_end);
4332 61319 bool is_separator = (wc == (my_wc_t)separator);
4333
4/4
✓ Branch 0 taken 58940 times.
✓ Branch 1 taken 2379 times.
✓ Branch 2 taken 3201 times.
✓ Branch 3 taken 55739 times.
 61319 if (is_separator || is_last_item) {
4334 5580 position++;
4335
4/4
✓ Branch 0 taken 3341 times.
✓ Branch 1 taken 2239 times.
✓ Branch 2 taken 3201 times.
✓ Branch 3 taken 140 times.
 5580 if (is_last_item && !is_separator) str_end = substr_end;
4336
3/4
✓ Branch 0 taken 5580 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1128 times.
✓ Branch 3 taken 4452 times.
 5580 if (!my_strnncoll(cs, (const uchar *)str_begin,
4337 (uint)(str_end - str_begin), find_str,
4338 find_str_len))
4339 1128 return (longlong)position;
4340 else
4341 4452 str_begin = substr_end;
4342 }
4343 60191 str_end = substr_end;
4344
3/4
✓ Branch 0 taken 2686 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1834 times.
✓ Branch 3 taken 852 times.
 2686 } else if (str_end - str_begin == 0 && find_str_len == 0 &&
4345
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1833 times.
 1834 wc == (my_wc_t)separator) {
4346 1 return ++position;
4347 } else {
4348 2685 return 0;
4349 }
4350 60191 }
4351 }
4352 258 return 0;
4353 }
4354
4355 487 longlong Item_func_bit_count::val_int() {
4356
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 487 times.
 487 assert(fixed);
4357
2/2
✓ Branch 0 taken 462 times.
✓ Branch 1 taken 25 times.
 487 if (bit_func_returns_binary(args[0], nullptr)) {
4358 462 String *s = args[0]->val_str(&str_value);
4359
2/4
✓ Branch 0 taken 462 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 462 times.
 462 if (args[0]->null_value || !s) return error_int();
4360
4361 462 const char *val = s->ptr();
4362
4363 462 longlong len = 0;
4364 462 size_t i = 0;
4365 462 size_t arg_length = s->length();
4366
2/2
✓ Branch 0 taken 530 times.
✓ Branch 1 taken 462 times.
 992 while (i + sizeof(longlong) <= arg_length) {
4367 530 len += my_count_bits(uint8korr(&val[i]));
4368 530 i += sizeof(longlong);
4369 }
4370
2/2
✓ Branch 0 taken 513 times.
✓ Branch 1 taken 462 times.
 975 while (i < arg_length) {
4371 513 len += _my_bits_nbits[(uchar)val[i]];
4372 513 i++;
4373 }
4374
4375 462 null_value = false;
4376 462 return len;
4377 }
4378
4379 25 ulonglong value = (ulonglong)args[0]->val_int();
4380
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 24 times.
 25 if (args[0]->null_value) return error_int(); /* purecov: inspected */
4381
4382 24 null_value = false;
4383 24 return (longlong)my_count_bits(value);
4384 }
4385
4386 /****************************************************************************
4387 ** Functions to handle dynamic loadable functions
4388 ****************************************************************************/
4389
4390 23226 udf_handler::udf_handler(udf_func *udf_arg)
4391 23226 : u_d(udf_arg),
4392 23226 m_args_extension(),
4393 23226 m_return_value_extension(&my_charset_bin, result_type()) {}
4394
4395 23206 void udf_handler::cleanup() {
4396
4/4
✓ Branch 0 taken 23199 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 1358 times.
✓ Branch 3 taken 21841 times.
 23206 if (!m_original || !m_initialized) return;
4397
4398 21841 clean_buffers();
4399 /*
4400 Make sure to not free the handler from the cleanup() call when
4401 (re)preparing the UDF function call. The handler allocated by
4402 udf_handler::fix_fields() will be used in execution.
4403 */
4404 21841 THD *thd = current_thd;
4405
6/6
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 21757 times.
✓ Branch 2 taken 47 times.
✓ Branch 3 taken 37 times.
✓ Branch 4 taken 47 times.
✓ Branch 5 taken 21794 times.
 21842 if (thd->stmt_arena->is_stmt_prepare() && thd->stmt_arena->is_repreparing)
4406 47 return;
4407
4408
4/4
✓ Branch 0 taken 21425 times.
✓ Branch 1 taken 369 times.
✓ Branch 2 taken 20762 times.
✓ Branch 3 taken 663 times.
 21794 if (m_init_func_called && u_d->func_deinit != nullptr) {
4409 20762 (*u_d->func_deinit)(&initid);
4410 20762 m_init_func_called = false;
4411 }
4412
1/2
✓ Branch 0 taken 21794 times.
✗ Branch 1 not taken.
 21794 DEBUG_SYNC(current_thd, "udf_handler_destroy_sync");
4413 21795 free_handler();
4414 }
4415
4416 23151 void udf_handler::clean_buffers() {
4417
2/2
✓ Branch 0 taken 10201 times.
✓ Branch 1 taken 12950 times.
 23151 if (buffers == nullptr) return;
4418
2/2
✓ Branch 0 taken 30508 times.
✓ Branch 1 taken 12950 times.
 43458 for (uint i = 0; i < f_args.arg_count; i++) {
4419 30508 buffers[i].mem_free();
4420 }
4421 }
4422
4423 23106 void udf_handler::free_handler() {
4424 // deinit() should have been called by cleanup()
4425
3/6
✓ Branch 0 taken 23106 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23106 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 23106 times.
✗ Branch 5 not taken.
 23106 assert(m_original && m_initialized && u_d != nullptr);
4426 23106 free_udf(u_d);
4427 23106 u_d = nullptr;
4428 23106 m_initialized = false;
4429 23106 }
4430
4431 23066 bool Item_udf_func::fix_fields(THD *thd, Item **) {
4432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23066 times.
 23066 assert(fixed == 0);
4433
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23069 times.
 23066 assert(!thd->is_error());
4434
2/2
✓ Branch 0 taken 1308 times.
✓ Branch 1 taken 21761 times.
 23069 if (udf.fix_fields(thd, this, arg_count, args)) return true;
4435
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21761 times.
 21761 if (thd->is_error()) return true;
4436 21761 used_tables_cache = udf.used_tables_cache;
4437 21761 fixed = true;
4438 21761 return false;
4439 }
4440
4441 23104 bool udf_handler::fix_fields(THD *thd, Item_result_field *func, uint arg_count,
4442 Item **arguments) {
4443 uchar buff[STACK_BUFF_ALLOC]; // Max argument in function
4444
1/2
✓ Branch 0 taken 23105 times.
✗ Branch 1 not taken.
 23104 DBUG_TRACE;
4445
4446
2/4
✓ Branch 0 taken 23106 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 23106 times.
 23105 if (check_stack_overrun(thd, STACK_MIN_SIZE, buff))
4447 ✗ return true; // Fatal error flag is set!
4448
4449
1/2
✓ Branch 0 taken 23106 times.
✗ Branch 1 not taken.
 23106 udf_func *tmp_udf = find_udf(u_d->name.str, (uint)u_d->name.length, true);
4450
4451
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23106 times.
 23106 if (!tmp_udf) {
4452 ✗ my_error(ER_CANT_FIND_UDF, MYF(0), u_d->name.str);
4453 ✗ return true;
4454 }
4455 23106 u_d = tmp_udf;
4456 23106 args = arguments;
4457
4458 23106 m_initialized = true; // Use count was incremented by find_udf()
4459 /*
4460 RAII wrapper to free the memory allocated in case of any failure while
4461 initializing the UDF
4462 */
4463 class cleanup_guard {
4464 public:
4465
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23106 times.
 23106 cleanup_guard(udf_handler *udf) : m_udf(udf) { assert(udf); }
4466 24417 ~cleanup_guard() {
4467
2/2
✓ Branch 0 taken 21795 times.
✓ Branch 1 taken 1311 times.
 23106 if (m_udf == nullptr) return;
4468 1311 m_udf->clean_buffers();
4469 1311 m_udf->free_handler();
4470 23106 }
4471 21795 void defer() { m_udf = nullptr; }
4472
4473 private:
4474 udf_handler *m_udf;
4475 23106 } udf_fun_guard(this);
4476
4477 /* Fix all arguments */
4478 23106 func->set_nullable(false);
4479 23106 used_tables_cache = 0;
4480
4481
2/2
✓ Branch 0 taken 12910 times.
✓ Branch 1 taken 10196 times.
 23106 if ((f_args.arg_count = arg_count)) {
4482 12910 if (!(f_args.arg_type =
4483
1/2
✓ Branch 0 taken 12910 times.
✗ Branch 1 not taken.
 12910 (Item_result *)(*THR_MALLOC)
4484
2/4
✓ Branch 0 taken 12910 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12910 times.
 12910 ->Alloc(f_args.arg_count * sizeof(Item_result)))) {
4485 ✗ return true;
4486 }
4487 uint i;
4488 Item **arg, **arg_end;
4489 12910 for (i = 0, arg = arguments, arg_end = arguments + arg_count;
4490
2/2
✓ Branch 0 taken 30410 times.
✓ Branch 1 taken 12907 times.
 43317 arg != arg_end; arg++, i++) {
4491
7/8
✓ Branch 0 taken 17739 times.
✓ Branch 1 taken 12671 times.
✓ Branch 2 taken 17739 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 17738 times.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 30409 times.
 30410 if (!(*arg)->fixed && (*arg)->fix_fields(thd, arg)) {
4492 1 return true;
4493 }
4494 // we can't assign 'item' before, because fix_fields() can change arg
4495 30409 Item *item = *arg;
4496
3/4
✓ Branch 0 taken 30409 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 30407 times.
 30409 if (item->check_cols(1)) {
4497 2 return true;
4498 }
4499 /*
4500 TODO: We should think about this. It is not always
4501 right way just to set an UDF result to return my_charset_bin
4502 if one argument has binary sorting order.
4503 The result collation should be calculated according to arguments
4504 derivations in some cases and should not in other cases.
4505 Moreover, some arguments can represent a numeric input
4506 which doesn't effect the result character set and collation.
4507 There is no a general rule for UDF. Everything depends on
4508 the particular user defined function.
4509 */
4510
2/2
✓ Branch 0 taken 7789 times.
✓ Branch 1 taken 22618 times.
 30407 if (item->collation.collation->state & MY_CS_BINSORT)
4511 7789 func->collation.set(&my_charset_bin);
4512 30407 func->m_nullable |= item->m_nullable;
4513 30407 func->add_accum_properties(item);
4514
1/2
✓ Branch 0 taken 30407 times.
✗ Branch 1 not taken.
 30407 used_tables_cache |= item->used_tables();
4515
1/2
✓ Branch 0 taken 30407 times.
✗ Branch 1 not taken.
 30407 f_args.arg_type[i] = item->result_type();
4516 }
4517 // TODO: why all following memory is not allocated with 1 call of sql_alloc?
4518 // if (!(buffers = new String[arg_count]) ||
4519 12907 if (!(buffers = pointer_cast<String *>(
4520
2/4
✓ Branch 0 taken 12907 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12907 times.
✗ Branch 3 not taken.
 12907 (*THR_MALLOC)->Alloc(sizeof(String) * arg_count))) ||
4521 12907 !(f_args.args =
4522
3/6
✓ Branch 0 taken 12907 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12907 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 12907 times.
✗ Branch 5 not taken.
 12907 (char **)(*THR_MALLOC)->Alloc(arg_count * sizeof(char *))) ||
4523 12907 !(f_args.lengths =
4524
3/6
✓ Branch 0 taken 12907 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12907 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 12907 times.
✗ Branch 5 not taken.
 12907 (ulong *)(*THR_MALLOC)->Alloc(arg_count * sizeof(long))) ||
4525 12907 !(f_args.maybe_null =
4526
3/6
✓ Branch 0 taken 12907 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12907 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 12907 times.
✗ Branch 5 not taken.
 12907 (char *)(*THR_MALLOC)->Alloc(arg_count * sizeof(char))) ||
4527
1/2
✓ Branch 0 taken 12907 times.
✗ Branch 1 not taken.
 12907 !(num_buffer = (char *)(*THR_MALLOC)
4528
2/4
✓ Branch 0 taken 12907 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12907 times.
✗ Branch 3 not taken.
 12907 ->Alloc(arg_count * ALIGN_SIZE(sizeof(double)))) ||
4529 12907 !(f_args.attributes =
4530
3/6
✓ Branch 0 taken 12907 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12907 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 12907 times.
✗ Branch 5 not taken.
 12907 (char **)(*THR_MALLOC)->Alloc(arg_count * sizeof(char *))) ||
4531 12907 !(f_args.attribute_lengths =
4532
5/10
✓ Branch 0 taken 12907 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12907 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 12907 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 12907 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 12907 times.
 38721 (ulong *)(*THR_MALLOC)->Alloc(arg_count * sizeof(long))) ||
4533 12907 !(m_args_extension.charset_info =
4534
1/2
✓ Branch 0 taken 12907 times.
✗ Branch 1 not taken.
 12907 (const CHARSET_INFO **)(*THR_MALLOC)
4535
2/4
✓ Branch 0 taken 12907 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12907 times.
 12907 ->Alloc(f_args.arg_count * sizeof(CHARSET_INFO *)))) {
4536 ✗ return true;
4537 }
4538 }
4539
2/2
✓ Branch 0 taken 30406 times.
✓ Branch 1 taken 23103 times.
 53509 for (uint i = 0; i < arg_count; i++) {
4540 30406 (void)::new (buffers + i) String;
4541 30406 m_args_extension.charset_info[i] = nullptr;
4542 }
4543
4544
2/4
✓ Branch 0 taken 23103 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 23103 times.
 23103 if (func->resolve_type(thd)) return true;
4545
4546 23103 initid.max_length = func->max_length;
4547 23103 initid.maybe_null = func->m_nullable;
4548 23103 initid.const_item = used_tables_cache == 0;
4549 23103 initid.decimals = func->decimals;
4550 23103 initid.ptr = nullptr;
4551 23103 initid.extension = &m_return_value_extension;
4552
4553
6/6
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 23019 times.
✓ Branch 2 taken 37 times.
✓ Branch 3 taken 47 times.
✓ Branch 4 taken 31 times.
✓ Branch 5 taken 23072 times.
 23140 if (thd->stmt_arena->is_stmt_prepare() && !thd->stmt_arena->is_repreparing &&
4554
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 6 times.
 37 !initid.const_item) {
4555 31 udf_fun_guard.defer();
4556 31 return false;
4557 }
4558
2/2
✓ Branch 0 taken 22733 times.
✓ Branch 1 taken 339 times.
 23072 if (u_d->func_init) {
4559
3/4
✓ Branch 0 taken 22732 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1308 times.
✓ Branch 3 taken 21424 times.
 22733 if (call_init_func()) {
4560 1308 return true;
4561 }
4562 21424 func->max_length = min<uint32>(initid.max_length, MAX_BLOB_WIDTH);
4563 21424 func->m_nullable = initid.maybe_null;
4564
4/4
✓ Branch 0 taken 8666 times.
✓ Branch 1 taken 12758 times.
✓ Branch 2 taken 3747 times.
✓ Branch 3 taken 4919 times.
 21424 if (!initid.const_item && used_tables_cache == 0)
4565 3747 used_tables_cache = RAND_TABLE_BIT;
4566 21424 func->decimals = min<uint>(initid.decimals, DECIMAL_NOT_SPECIFIED);
4567 /*
4568 For UDFs of type string, override character set and collation from
4569 return value extension specification.
4570 */
4571
2/2
✓ Branch 0 taken 16977 times.
✓ Branch 1 taken 4448 times.
 21424 if (result_type() == STRING_RESULT)
4572 16977 func->set_data_type_string(func->max_length,
4573 m_return_value_extension.charset_info);
4574 }
4575 /*
4576 UDF initialization complete so leave the freeing up resources to
4577 cleanup method.
4578 */
4579 21764 udf_fun_guard.defer();
4580 21764 return false;
4581 23106 }
4582
4583 22733 bool udf_handler::call_init_func() {
4584 char init_msg_buff[MYSQL_ERRMSG_SIZE];
4585 22733 *init_msg_buff = '\0';
4586 22733 char *to = num_buffer;
4587 22733 f_args.extension = &m_args_extension;
4588
4589
2/2
✓ Branch 0 taken 30299 times.
✓ Branch 1 taken 22734 times.
 53033 for (uint i = 0; i < f_args.arg_count; i++) {
4590 /*
4591 For a constant argument i, args->args[i] points to the argument value.
4592 For non-constant, args->args[i] is NULL.
4593 */
4594 30299 f_args.args[i] = nullptr; // Non-const unless updated below
4595
4596 30299 f_args.lengths[i] = args[i]->max_length;
4597 30299 f_args.maybe_null[i] = args[i]->m_nullable;
4598 30299 f_args.attributes[i] = const_cast<char *>(args[i]->item_name.ptr());
4599 30300 f_args.attribute_lengths[i] = args[i]->item_name.length();
4600 30300 m_args_extension.charset_info[i] = args[i]->collation.collation;
4601
4602
6/8
✓ Branch 0 taken 30300 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29971 times.
✓ Branch 3 taken 329 times.
✓ Branch 4 taken 29971 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 29971 times.
✓ Branch 7 taken 329 times.
 30300 if (args[i]->const_for_execution() && !args[i]->has_subquery()) {
4603
4/6
✓ Branch 0 taken 29971 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 25824 times.
✓ Branch 3 taken 4142 times.
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
 29971 switch (args[i]->result_type()) {
4604 25824 case STRING_RESULT:
4605 case DECIMAL_RESULT: {
4606
1/2
✓ Branch 0 taken 25824 times.
✗ Branch 1 not taken.
 25824 get_string(i);
4607 25824 break;
4608 }
4609 4142 case INT_RESULT:
4610
1/2
✓ Branch 0 taken 4142 times.
✗ Branch 1 not taken.
 4142 *((longlong *)to) = args[i]->val_int();
4611
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 4141 times.
 4142 if (args[i]->null_value) continue;
4612 4141 f_args.args[i] = to;
4613 4141 to += ALIGN_SIZE(sizeof(longlong));
4614 4141 break;
4615 5 case REAL_RESULT:
4616
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 *((double *)to) = args[i]->val_real();
4617
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 if (args[i]->null_value) continue;
4618 5 f_args.args[i] = to;
4619 5 to += ALIGN_SIZE(sizeof(double));
4620 5 break;
4621 ✗ case ROW_RESULT:
4622 default:
4623 // This case should never be chosen
4624 ✗ assert(0);
4625 break;
4626 }
4627 }
4628 }
4629 22734 Udf_func_init init = u_d->func_init;
4630
3/4
✓ Branch 0 taken 22732 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1308 times.
✓ Branch 3 taken 21424 times.
 22734 if ((error = (uchar)init(&initid, &f_args, init_msg_buff))) {
4631
1/2
✓ Branch 0 taken 1308 times.
✗ Branch 1 not taken.
 1308 my_error(ER_CANT_INITIALIZE_UDF, MYF(0), u_d->name.str, init_msg_buff);
4632 1308 return true;
4633 }
4634 21424 m_init_func_called = true;
4635 21424 return false;
4636 }
4637
4638 21958 bool udf_handler::get_arguments() {
4639
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21958 times.
 21958 if (error) return true; // Got an error earlier
4640 21958 char *to = num_buffer;
4641
2/2
✓ Branch 0 taken 27830 times.
✓ Branch 1 taken 21958 times.
 49788 for (uint i = 0; i < f_args.arg_count; i++) {
4642 27830 f_args.args[i] = nullptr;
4643
4/5
✓ Branch 0 taken 24131 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 3625 times.
✓ Branch 3 taken 71 times.
✗ Branch 4 not taken.
 27830 switch (f_args.arg_type[i]) {
4644 24131 case STRING_RESULT:
4645
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24131 times.
 24131 if (get_and_convert_string(i)) return true;
4646 24131 break;
4647 3 case DECIMAL_RESULT:
4648 3 get_string(i);
4649 3 break;
4650 3625 case INT_RESULT:
4651 3625 *((longlong *)to) = args[i]->val_int();
4652
2/2
✓ Branch 0 taken 3616 times.
✓ Branch 1 taken 9 times.
 3625 if (!args[i]->null_value) {
4653 3616 f_args.args[i] = to;
4654 3616 to += ALIGN_SIZE(sizeof(longlong));
4655 }
4656 3625 break;
4657 71 case REAL_RESULT:
4658 71 *((double *)to) = args[i]->val_real();
4659
2/2
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 3 times.
 71 if (!args[i]->null_value) {
4660 68 f_args.args[i] = to;
4661 68 to += ALIGN_SIZE(sizeof(double));
4662 }
4663 71 break;
4664 ✗ case ROW_RESULT:
4665 default:
4666 // This case should never be chosen
4667 ✗ assert(0);
4668 break;
4669 }
4670 }
4671 21958 return false;
4672 }
4673
4674 85 double udf_handler::val_real(bool *null_value) {
4675
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
 85 assert(is_initialized());
4676 85 is_null = 0;
4677
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
 85 if (get_arguments()) {
4678 ✗ *null_value = true;
4679 ✗ return 0.0;
4680 }
4681 85 Udf_func_double func = (Udf_func_double)u_d->func;
4682 85 double tmp = func(&initid, &f_args, &is_null, &error);
4683
4/4
✓ Branch 0 taken 80 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 76 times.
 85 if (is_null || error) {
4684 9 *null_value = true;
4685 9 return 0.0;
4686 }
4687 76 *null_value = false;
4688 76 return tmp;
4689 }
4690
4691 4733 longlong udf_handler::val_int(bool *null_value) {
4692
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4733 times.
 4733 assert(is_initialized());
4693 4733 is_null = 0;
4694
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4733 times.
 4733 if (get_arguments()) {
4695 ✗ *null_value = true;
4696 ✗ return 0LL;
4697 }
4698
1/2
✓ Branch 0 taken 4733 times.
✗ Branch 1 not taken.
 4733 DEBUG_SYNC(current_thd, "execute_uninstall_component");
4699 4733 Udf_func_longlong func = (Udf_func_longlong)u_d->func;
4700 4733 longlong tmp = func(&initid, &f_args, &is_null, &error);
4701
4/4
✓ Branch 0 taken 4689 times.
✓ Branch 1 taken 44 times.
✓ Branch 2 taken 362 times.
✓ Branch 3 taken 4327 times.
 4733 if (is_null || error) {
4702 406 *null_value = true;
4703 406 return 0LL;
4704 }
4705 4327 *null_value = false;
4706 4327 return tmp;
4707 }
4708
4709 /**
4710 @return
4711 (String*)NULL in case of NULL values
4712 */
4713 17065 String *udf_handler::val_str(String *str, String *save_str) {
4714 17065 uchar is_null_tmp = 0;
4715 ulong res_length;
4716
1/2
✓ Branch 0 taken 17068 times.
✗ Branch 1 not taken.
 17065 DBUG_TRACE;
4717
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17068 times.
 17068 assert(is_initialized());
4718
4719
2/4
✓ Branch 0 taken 17067 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 17067 times.
 17068 if (get_arguments()) return nullptr;
4720
4721
3/6
✓ Branch 0 taken 17066 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17066 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 17066 times.
✗ Branch 5 not taken.
 17067 DEBUG_SYNC(current_thd, "before_string_udf_execution");
4722 17066 Udf_func_string func = reinterpret_cast<Udf_func_string>(u_d->func);
4723
4724
2/2
✓ Branch 0 taken 6736 times.
✓ Branch 1 taken 10332 times.
 17066 if ((res_length = str->alloced_length()) <
4725 MAX_FIELD_WIDTH) { // This happens VERY seldom
4726
2/4
✓ Branch 0 taken 6736 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6736 times.
 6736 if (str->alloc(MAX_FIELD_WIDTH)) {
4727 ✗ error = 1;
4728 ✗ return nullptr;
4729 }
4730 }
4731 char *res =
4732
1/2
✓ Branch 0 taken 17068 times.
✗ Branch 1 not taken.
 17068 func(&initid, &f_args, str->ptr(), &res_length, &is_null_tmp, &error);
4733
3/8
✓ Branch 0 taken 17068 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17068 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 17068 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 17068 DBUG_PRINT("info", ("udf func returned, res_length: %lu", res_length));
4734
6/6
✓ Branch 0 taken 16859 times.
✓ Branch 1 taken 209 times.
✓ Branch 2 taken 16644 times.
✓ Branch 3 taken 215 times.
✓ Branch 4 taken 323 times.
✓ Branch 5 taken 16321 times.
 17068 if (is_null_tmp || !res || error) // The !res is for safety
4735 {
4736
3/8
✓ Branch 0 taken 747 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 747 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 747 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 747 DBUG_PRINT("info", ("Null or error"));
4737 747 return nullptr;
4738 }
4739
4740
1/2
✓ Branch 0 taken 16321 times.
✗ Branch 1 not taken.
 16321 String *res_str = result_string(res, res_length, str, save_str);
4741
3/8
✓ Branch 0 taken 16321 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16321 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 16321 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 16321 DBUG_PRINT("exit", ("res_str: %s", res_str->ptr()));
4742 16321 return res_str;
4743 17068 }
4744
4745 /*
4746 For the moment, UDF functions are returning DECIMAL values as strings
4747 */
4748
4749 ✗ my_decimal *udf_handler::val_decimal(bool *null_value, my_decimal *dec_buf) {
4750 char buf[DECIMAL_MAX_STR_LENGTH + 1];
4751 ✗ ulong res_length = DECIMAL_MAX_STR_LENGTH;
4752
4753 ✗ assert(is_initialized());
4754
4755 ✗ if (get_arguments()) {
4756 ✗ *null_value = true;
4757 ✗ return nullptr;
4758 }
4759 ✗ Udf_func_string func = reinterpret_cast<Udf_func_string>(u_d->func);
4760
4761 ✗ char *res = func(&initid, &f_args, buf, &res_length, &is_null, &error);
4762 ✗ if (is_null || error) {
4763 ✗ *null_value = true;
4764 ✗ return nullptr;
4765 }
4766 ✗ const char *end = res + res_length;
4767 ✗ str2my_decimal(E_DEC_FATAL_ERROR, res, dec_buf, &end);
4768 ✗ return dec_buf;
4769 }
4770
4771 48 void udf_handler::clear() {
4772
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
 48 assert(is_initialized());
4773 48 is_null = 0;
4774 48 Udf_func_clear func = u_d->func_clear;
4775 48 func(&initid, &is_null, &error);
4776 48 }
4777
4778 74 void udf_handler::add(bool *null_value) {
4779
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 74 times.
 74 assert(is_initialized());
4780
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 74 times.
 74 if (get_arguments()) {
4781 ✗ *null_value = true;
4782 ✗ return;
4783 }
4784 74 Udf_func_add func = u_d->func_add;
4785 74 func(&initid, &f_args, &is_null, &error);
4786
2/4
✓ Branch 0 taken 74 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 74 times.
 74 *null_value = (bool)(is_null || error);
4787 }
4788
4789 /**
4790 Process the result string returned by the udf() method. The charset
4791 info might have changed therefore updates the same String. If user
4792 used the input String as result string then return the same.
4793
4794 @param [in] res the result string returned by the udf() method.
4795 @param [in] res_length length of the string
4796 @param [out] str The input result string passed to the udf() method
4797 @param [out] save_str Keeps copy of the returned String
4798
4799 @returns A pointer to either the str or save_str that points
4800 to final result String
4801 */
4802 16320 String *udf_handler::result_string(const char *res, size_t res_length,
4803 String *str, String *save_str) {
4804 16320 const auto *charset = m_return_value_extension.charset_info;
4805 16320 String *res_str = nullptr;
4806
2/2
✓ Branch 0 taken 9172 times.
✓ Branch 1 taken 7149 times.
 16320 if (res == str->ptr()) {
4807 9172 res_str = str;
4808 9172 res_str->length(res_length);
4809 9172 res_str->set_charset(charset);
4810 } else {
4811 7149 res_str = save_str;
4812 7149 res_str->set(res, res_length, charset);
4813 }
4814 16321 return res_str;
4815 }
4816
4817 /**
4818 Get the details of the input String arguments.
4819
4820 @param [in] index of the argument to be looked in the arguments array
4821 */
4822 25827 void udf_handler::get_string(uint index) {
4823 25827 String *res = args[index]->val_str(&buffers[index]);
4824
2/2
✓ Branch 0 taken 25416 times.
✓ Branch 1 taken 411 times.
 25827 if (!args[index]->null_value) {
4825 25416 f_args.args[index] = res->ptr();
4826 25416 f_args.lengths[index] = res->length();
4827 } else {
4828 411 f_args.lengths[index] = 0;
4829 }
4830 25827 }
4831
4832 /**
4833 Get the details of the input String argument.
4834 If the charset of the input argument is not same as specified by the
4835 user then convert the String.
4836
4837 @param [in] index of the argument to be looked in the arguments array
4838
4839 @retval false Able to fetch the argument details
4840 @retval true Otherwise
4841 */
4842 24131 bool udf_handler::get_and_convert_string(uint index) {
4843 24131 String *res = args[index]->val_str(&buffers[index]);
4844
4845 /* m_args_extension.charset_info[index] is a legitimate charset */
4846
4/4
✓ Branch 0 taken 23928 times.
✓ Branch 1 taken 203 times.
✓ Branch 2 taken 23927 times.
✓ Branch 3 taken 1 times.
 24131 if (res != nullptr && m_args_extension.charset_info[index] != nullptr) {
4847
2/2
✓ Branch 0 taken 1405 times.
✓ Branch 1 taken 22522 times.
 23927 if (res->charset() != m_args_extension.charset_info[index]) {
4848 1405 String temp;
4849 uint dummy;
4850
2/4
✓ Branch 0 taken 1405 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1405 times.
 1405 if (temp.copy(res->ptr(), res->length(), res->charset(),
4851 1405 m_args_extension.charset_info[index], &dummy)) {
4852 ✗ return true;
4853 }
4854 1405 *res = std::move(temp);
4855
1/2
✓ Branch 0 taken 1405 times.
✗ Branch 1 not taken.
 1405 }
4856 }
4857
2/2
✓ Branch 0 taken 23928 times.
✓ Branch 1 taken 203 times.
 24131 if (!args[index]->null_value) {
4858 23928 f_args.args[index] = res->c_ptr_safe();
4859 23928 f_args.lengths[index] = res->length();
4860 } else {
4861 203 f_args.lengths[index] = 0;
4862 }
4863 24131 return false;
4864 }
4865
4866 23187 bool Item_udf_func::itemize(Parse_context *pc, Item **res) {
4867
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23189 times.
 23187 if (skip_itemize(res)) return false;
4868
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 23186 times.
 23189 if (super::itemize(pc, res)) return true;
4869 23186 pc->thd->lex->set_has_udf();
4870 23186 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_UDF);
4871 23187 pc->thd->lex->safe_to_cache_query = false;
4872 23187 return false;
4873 }
4874
4875 23158 void Item_udf_func::cleanup() {
4876 23158 udf.cleanup();
4877 23160 str_value.mem_free();
4878 23160 Item_func::cleanup();
4879 23160 }
4880
4881 14 void Item_udf_func::print(const THD *thd, String *str,
4882 enum_query_type query_type) const {
4883
1/2
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
 14 str->append(func_name());
4884 14 str->append('(');
4885
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 14 times.
 28 for (uint i = 0; i < arg_count; i++) {
4886
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
 14 if (i != 0) str->append(',');
4887 14 args[i]->print_item_w_name(thd, str, query_type);
4888 }
4889 14 str->append(')');
4890 14 }
4891
4892 67 double Item_func_udf_float::val_real() {
4893
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 67 times.
 67 assert(fixed == 1);
4894
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 67 times.
 67 DBUG_PRINT("info", ("result_type: %d arg_count: %d", args[0]->result_type(),
4895 arg_count));
4896 67 return udf.val_real(&null_value);
4897 }
4898
4899 ✗ String *Item_func_udf_float::val_str(String *str) {
4900 ✗ assert(fixed == 1);
4901 ✗ double nr = val_real();
4902 ✗ if (null_value) return nullptr; /* purecov: inspected */
4903 ✗ str->set_real(nr, decimals, &my_charset_bin);
4904 ✗ return str;
4905 }
4906
4907 4707 longlong Item_func_udf_int::val_int() {
4908
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4707 times.
 4707 assert(fixed == 1);
4909 4707 return udf.val_int(&null_value);
4910 }
4911
4912 42 String *Item_func_udf_int::val_str(String *str) {
4913
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
 42 assert(fixed == 1);
4914 42 longlong nr = val_int();
4915
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
 42 if (null_value) return nullptr;
4916 42 str->set_int(nr, unsigned_flag, &my_charset_bin);
4917 42 return str;
4918 }
4919
4920 ✗ longlong Item_func_udf_decimal::val_int() {
4921 ✗ my_decimal dec_buf, *dec = udf.val_decimal(&null_value, &dec_buf);
4922 longlong result;
4923 ✗ if (null_value) return 0;
4924 ✗ my_decimal2int(E_DEC_FATAL_ERROR, dec, unsigned_flag, &result);
4925 ✗ return result;
4926 }
4927
4928 ✗ double Item_func_udf_decimal::val_real() {
4929 ✗ my_decimal dec_buf, *dec = udf.val_decimal(&null_value, &dec_buf);
4930 double result;
4931 ✗ if (null_value) return 0.0;
4932 ✗ my_decimal2double(E_DEC_FATAL_ERROR, dec, &result);
4933 ✗ return result;
4934 }
4935
4936 ✗ my_decimal *Item_func_udf_decimal::val_decimal(my_decimal *dec_buf) {
4937 ✗ return udf.val_decimal(&null_value, dec_buf);
4938 }
4939
4940 ✗ String *Item_func_udf_decimal::val_str(String *str) {
4941 ✗ my_decimal dec_buf, *dec = udf.val_decimal(&null_value, &dec_buf);
4942 ✗ if (null_value) return nullptr;
4943 ✗ if (str->length() < DECIMAL_MAX_STR_LENGTH)
4944 ✗ str->length(DECIMAL_MAX_STR_LENGTH);
4945 ✗ my_decimal_round(E_DEC_FATAL_ERROR, dec, decimals, false, &dec_buf);
4946 ✗ my_decimal2string(E_DEC_FATAL_ERROR, &dec_buf, str);
4947 ✗ return str;
4948 }
4949
4950 ✗ bool Item_func_udf_decimal::resolve_type(THD *) {
4951 ✗ set_data_type(MYSQL_TYPE_NEWDECIMAL);
4952 ✗ fix_num_length_and_dec();
4953 ✗ return false;
4954 }
4955
4956 /* Default max_length is max argument length */
4957
4958 17557 bool Item_func_udf_str::resolve_type(THD *) {
4959 17557 uint result_length = 0;
4960
2/2
✓ Branch 0 taken 17737 times.
✓ Branch 1 taken 17557 times.
 35294 for (uint i = 0; i < arg_count; i++)
4961 17737 result_length = max(result_length, args[i]->max_length);
4962 // If the UDF has an init function, this may be overridden later.
4963 17557 set_data_type_string(result_length, &my_charset_bin);
4964 17557 return false;
4965 }
4966
4967 17065 String *Item_func_udf_str::val_str(String *str) {
4968
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17065 times.
 17065 assert(fixed == 1);
4969 17065 String *res = udf.val_str(str, &str_value);
4970 17068 null_value = !res;
4971 17068 return res;
4972 }
4973
4974 33844 bool Item_source_pos_wait::itemize(Parse_context *pc, Item **res) {
4975
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33844 times.
 33844 if (skip_itemize(res)) return false;
4976
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33844 times.
 33844 if (super::itemize(pc, res)) return true;
4977 33844 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
4978 33844 pc->thd->lex->safe_to_cache_query = false;
4979 33844 return false;
4980 }
4981
4982 /**
4983 Wait until we are at or past the given position in the master binlog
4984 on the slave.
4985 */
4986
4987 33839 longlong Item_source_pos_wait::val_int() {
4988
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33839 times.
 33839 assert(fixed == 1);
4989 33839 THD *thd = current_thd;
4990 33839 String *log_name = args[0]->val_str(&value);
4991 33839 int event_count = 0;
4992
4993 33839 null_value = false;
4994
4/8
✓ Branch 0 taken 33839 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33839 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 33839 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 33839 times.
 33839 if (thd->slave_thread || !log_name || !log_name->length()) {
4995 ✗ null_value = true;
4996 ✗ return 0;
4997 }
4998 Master_info *mi;
4999 33839 longlong pos = (ulong)args[1]->val_int();
5000
2/2
✓ Branch 0 taken 33830 times.
✓ Branch 1 taken 9 times.
 33839 double timeout = (arg_count >= 3) ? args[2]->val_real() : 0;
5001
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 33834 times.
 33839 if (timeout < 0) {
5002
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
 5 if (thd->is_strict_mode()) {
5003 3 my_error(ER_WRONG_ARGUMENTS, MYF(0), "SOURCE_POS_WAIT.");
5004 } else {
5005 2 push_warning_printf(thd, Sql_condition::SL_WARNING, ER_WRONG_ARGUMENTS,
5006 ER_THD(thd, ER_WRONG_ARGUMENTS), "SOURCE_POS_WAIT.");
5007 2 null_value = true;
5008 }
5009 5 return 0;
5010 }
5011
5012 33834 channel_map.rdlock();
5013
5014
2/2
✓ Branch 0 taken 216 times.
✓ Branch 1 taken 33618 times.
 33834 if (arg_count == 4) {
5015 String *channel_str;
5016
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 216 times.
 216 if (!(channel_str = args[3]->val_str(&value))) {
5017 ✗ null_value = true;
5018 ✗ return 0;
5019 }
5020
5021 216 mi = channel_map.get_mi(channel_str->ptr());
5022
5023 } else {
5024
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 33614 times.
 33618 if (channel_map.get_num_instances() > 1) {
5025 4 mi = nullptr;
5026 4 my_error(ER_SLAVE_MULTIPLE_CHANNELS_CMD, MYF(0));
5027 } else
5028 33614 mi = channel_map.get_default_channel_mi();
5029 }
5030
5031
2/2
✓ Branch 0 taken 33826 times.
✓ Branch 1 taken 8 times.
 33834 if (mi != nullptr) mi->inc_reference();
5032
5033 33834 channel_map.unlock();
5034
5035
6/6
✓ Branch 0 taken 33826 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 22 times.
✓ Branch 3 taken 33804 times.
✓ Branch 4 taken 30 times.
✓ Branch 5 taken 33804 times.
 33834 if (mi == nullptr || (event_count = mi->rli->wait_for_pos(thd, log_name, pos,
5036 timeout)) == -2) {
5037 30 null_value = true;
5038 30 event_count = 0;
5039 }
5040
5041
2/2
✓ Branch 0 taken 33826 times.
✓ Branch 1 taken 8 times.
 33834 if (mi != nullptr) mi->dec_reference();
5042 33834 return event_count;
5043 }
5044
5045 7 longlong Item_master_pos_wait::val_int() {
5046 7 push_deprecated_warn(current_thd, "MASTER_POS_WAIT", "SOURCE_POS_WAIT");
5047 7 return Item_source_pos_wait::val_int();
5048 }
5049
5050 2277 bool Item_wait_for_executed_gtid_set::itemize(Parse_context *pc, Item **res) {
5051
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2277 times.
 2277 if (skip_itemize(res)) return false;
5052
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2277 times.
 2277 if (super::itemize(pc, res)) return true;
5053 /*
5054 It is unsafe because the return value depends on timing. If the timeout
5055 happens, the return value is different from the one in which the function
5056 returns with success.
5057 */
5058 2277 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
5059 2277 pc->thd->lex->safe_to_cache_query = false;
5060 2277 return false;
5061 }
5062
5063 /**
5064 Wait until the given gtid_set is found in the executed gtid_set independent
5065 of the slave threads.
5066 */
5067 4050 longlong Item_wait_for_executed_gtid_set::val_int() {
5068
1/2
✓ Branch 0 taken 4050 times.
✗ Branch 1 not taken.
 4050 DBUG_TRACE;
5069
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4050 times.
 4050 assert(fixed);
5070
1/2
✓ Branch 0 taken 4050 times.
✗ Branch 1 not taken.
 4050 THD *thd = current_thd;
5071
5072 4050 null_value = false;
5073
5074
1/2
✓ Branch 0 taken 4050 times.
✗ Branch 1 not taken.
 4050 String *gtid_text = args[0]->val_str(&value);
5075
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4046 times.
 4050 if (gtid_text == nullptr) {
5076 /*
5077 Usually, an argument that is NULL causes an SQL function to return NULL,
5078 however since this is a function with side-effects, a NULL value is
5079 treated as an error.
5080 */
5081
2/4
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 4 if (!thd->is_error()) {
5082
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 my_error(ER_MALFORMED_GTID_SET_SPECIFICATION, MYF(0), "NULL");
5083 }
5084 4 return error_int();
5085 }
5086
5087 // Waiting for a GTID in a slave thread could cause the slave to
5088 // hang/deadlock.
5089 // @todo: Return error instead of NULL
5090
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4044 times.
 4046 if (thd->slave_thread) {
5091 2 return error_int();
5092 }
5093
5094
1/2
✓ Branch 0 taken 4044 times.
✗ Branch 1 not taken.
 4044 Gtid_set wait_for_gtid_set(global_sid_map, nullptr);
5095
5096
1/2
✓ Branch 0 taken 4044 times.
✗ Branch 1 not taken.
 4044 global_sid_lock->rdlock();
5097
3/4
✓ Branch 0 taken 4044 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 4040 times.
 4044 if (global_gtid_mode.get() == Gtid_mode::OFF) {
5098
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 global_sid_lock->unlock();
5099
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 my_error(ER_GTID_MODE_OFF, MYF(0), "use WAIT_FOR_EXECUTED_GTID_SET");
5100 4 return error_int();
5101 }
5102
5103
4/6
✓ Branch 0 taken 4040 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4040 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 4037 times.
 4040 if (wait_for_gtid_set.add_gtid_text(gtid_text->c_ptr_safe()) !=
5104 RETURN_STATUS_OK) {
5105
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 global_sid_lock->unlock();
5106 // Error has already been generated.
5107 3 return error_int();
5108 }
5109
5110 // Cannot wait for a GTID that the thread owns since that would
5111 // immediately deadlock.
5112
4/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4035 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 4036 times.
 4039 if (thd->owned_gtid.sidno > 0 &&
5113
3/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
 2 wait_for_gtid_set.contains_gtid(thd->owned_gtid)) {
5114 char buf[Gtid::MAX_TEXT_LENGTH + 1];
5115
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 thd->owned_gtid.to_string(global_sid_map, buf);
5116
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 global_sid_lock->unlock();
5117
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 my_error(ER_CANT_WAIT_FOR_EXECUTED_GTID_SET_WHILE_OWNING_A_GTID, MYF(0),
5118 buf);
5119 1 return error_int();
5120 }
5121
5122
1/2
✓ Branch 0 taken 4036 times.
✗ Branch 1 not taken.
 4036 gtid_state->begin_gtid_wait();
5123
5124
3/4
✓ Branch 0 taken 3965 times.
✓ Branch 1 taken 71 times.
✓ Branch 2 taken 3965 times.
✗ Branch 3 not taken.
 4036 double timeout = (arg_count == 2) ? args[1]->val_real() : 0;
5125
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4030 times.
 4036 if (timeout < 0) {
5126
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
 6 if (thd->is_strict_mode()) {
5127
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 my_error(ER_WRONG_ARGUMENTS, MYF(0), "WAIT_FOR_EXECUTED_GTID_SET.");
5128 } else {
5129
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 push_warning_printf(thd, Sql_condition::SL_WARNING, ER_WRONG_ARGUMENTS,
5130 ER_THD(thd, ER_WRONG_ARGUMENTS),
5131 "WAIT_FOR_EXECUTED_GTID_SET.");
5132 }
5133
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 gtid_state->end_gtid_wait();
5134
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 global_sid_lock->unlock();
5135 6 return error_int();
5136 }
5137
5138
1/2
✓ Branch 0 taken 4030 times.
✗ Branch 1 not taken.
 4030 bool result = gtid_state->wait_for_gtid_set(thd, &wait_for_gtid_set, timeout);
5139
1/2
✓ Branch 0 taken 4030 times.
✗ Branch 1 not taken.
 4030 global_sid_lock->unlock();
5140
1/2
✓ Branch 0 taken 4030 times.
✗ Branch 1 not taken.
 4030 gtid_state->end_gtid_wait();
5141
5142 4030 return result;
5143 4050 }
5144
5145 19 Item_master_gtid_set_wait::Item_master_gtid_set_wait(const POS &pos, Item *a)
5146 19 : Item_int_func(pos, a) {
5147
2/4
✓ Branch 0 taken 19 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
✗ Branch 3 not taken.
 19 push_deprecated_warn(current_thd, "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS",
5148 "WAIT_FOR_EXECUTED_GTID_SET");
5149 19 }
5150
5151 1917 Item_master_gtid_set_wait::Item_master_gtid_set_wait(const POS &pos, Item *a,
5152 1917 Item *b)
5153 1917 : Item_int_func(pos, a, b) {
5154
2/4
✓ Branch 0 taken 1917 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1917 times.
✗ Branch 3 not taken.
 1917 push_deprecated_warn(current_thd, "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS",
5155 "WAIT_FOR_EXECUTED_GTID_SET");
5156 1917 }
5157
5158 88 Item_master_gtid_set_wait::Item_master_gtid_set_wait(const POS &pos, Item *a,
5159 88 Item *b, Item *c)
5160 88 : Item_int_func(pos, a, b, c) {
5161
2/4
✓ Branch 0 taken 88 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.
✗ Branch 3 not taken.
 88 push_deprecated_warn(current_thd, "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS",
5162 "WAIT_FOR_EXECUTED_GTID_SET");
5163 88 }
5164
5165 2024 bool Item_master_gtid_set_wait::itemize(Parse_context *pc, Item **res) {
5166
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2024 times.
 2024 if (skip_itemize(res)) return false;
5167
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2024 times.
 2024 if (super::itemize(pc, res)) return true;
5168 2024 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
5169 2024 pc->thd->lex->safe_to_cache_query = false;
5170 2024 return false;
5171 }
5172
5173 2021 longlong Item_master_gtid_set_wait::val_int() {
5174
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2021 times.
 2021 assert(fixed);
5175
1/2
✓ Branch 0 taken 2021 times.
✗ Branch 1 not taken.
 2021 DBUG_TRACE;
5176 2021 int event_count = 0;
5177
5178 2021 null_value = false;
5179
5180
1/2
✓ Branch 0 taken 2021 times.
✗ Branch 1 not taken.
 2021 String *gtid = args[0]->val_str(&value);
5181
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2021 times.
 2021 if (gtid == nullptr) {
5182 ✗ return error_int();
5183 }
5184
5185
1/2
✓ Branch 0 taken 2021 times.
✗ Branch 1 not taken.
 2021 THD *thd = current_thd;
5186 2021 Master_info *mi = nullptr;
5187
3/4
✓ Branch 0 taken 2003 times.
✓ Branch 1 taken 18 times.
✓ Branch 2 taken 2003 times.
✗ Branch 3 not taken.
 2021 double timeout = (arg_count >= 2) ? args[1]->val_real() : 0;
5188
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2017 times.
 2021 if (timeout < 0) {
5189
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
 4 if (thd->is_strict_mode()) {
5190
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 my_error(ER_WRONG_ARGUMENTS, MYF(0),
5191 "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS.");
5192 } else {
5193
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
 2 push_warning_printf(thd, Sql_condition::SL_WARNING, ER_WRONG_ARGUMENTS,
5194 ER_THD(thd, ER_WRONG_ARGUMENTS),
5195 "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS.");
5196 }
5197 4 return error_int();
5198 }
5199
5200
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2017 times.
 2017 if (thd->slave_thread) {
5201 ✗ return error_int();
5202 }
5203
5204
1/2
✓ Branch 0 taken 2017 times.
✗ Branch 1 not taken.
 2017 channel_map.rdlock();
5205
5206 /* If replication channel is mentioned */
5207
2/2
✓ Branch 0 taken 87 times.
✓ Branch 1 taken 1930 times.
 2017 if (arg_count == 3) {
5208 String *channel_str;
5209
2/4
✓ Branch 0 taken 87 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 87 times.
 87 if (!(channel_str = args[2]->val_str(&value))) {
5210 ✗ channel_map.unlock();
5211 ✗ return error_int();
5212 }
5213
1/2
✓ Branch 0 taken 87 times.
✗ Branch 1 not taken.
 87 mi = channel_map.get_mi(channel_str->ptr());
5214 } else {
5215
3/4
✓ Branch 0 taken 1930 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 1927 times.
 1930 if (channel_map.get_num_instances() > 1) {
5216
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 channel_map.unlock();
5217 3 mi = nullptr;
5218
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 my_error(ER_SLAVE_MULTIPLE_CHANNELS_CMD, MYF(0));
5219 3 return error_int();
5220 } else
5221
1/2
✓ Branch 0 taken 1927 times.
✗ Branch 1 not taken.
 1927 mi = channel_map.get_default_channel_mi();
5222 }
5223
5224
4/4
✓ Branch 0 taken 2013 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2013 times.
 4027 if ((mi != nullptr) &&
5225
3/4
✓ Branch 0 taken 2013 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2012 times.
 2013 mi->rli->m_assign_gtids_to_anonymous_transactions_info.get_type() >
5226 Assign_gtids_to_anonymous_transactions_info::enum_type::AGAT_OFF) {
5227
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 my_error(ER_CANT_SET_ANONYMOUS_TO_GTID_AND_WAIT_UNTIL_SQL_THD_AFTER_GTIDS,
5228 MYF(0));
5229
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 channel_map.unlock();
5230 1 return error_int();
5231 }
5232
3/4
✓ Branch 0 taken 2013 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2012 times.
 2013 if (global_gtid_mode.get() == Gtid_mode::OFF) {
5233
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 channel_map.unlock();
5234 1 return error_int();
5235 }
5236
1/2
✓ Branch 0 taken 2012 times.
✗ Branch 1 not taken.
 2012 gtid_state->begin_gtid_wait();
5237
5238
1/2
✓ Branch 0 taken 2012 times.
✗ Branch 1 not taken.
 2012 if (mi != nullptr) mi->inc_reference();
5239
5240
1/2
✓ Branch 0 taken 2012 times.
✗ Branch 1 not taken.
 2012 channel_map.unlock();
5241
5242 2012 bool null_result = false;
5243
5244
2/4
✓ Branch 0 taken 2012 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2012 times.
✗ Branch 3 not taken.
 2012 if (mi != nullptr && mi->rli != nullptr) {
5245
1/2
✓ Branch 0 taken 2012 times.
✗ Branch 1 not taken.
 2012 event_count = mi->rli->wait_for_gtid_set(thd, gtid, timeout);
5246
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2011 times.
 2012 if (event_count == -2) {
5247 1 null_result = true;
5248 }
5249 } else {
5250 /*
5251 Replication has not been set up, we should return NULL;
5252 */
5253 ✗ null_result = true;
5254 }
5255
1/2
✓ Branch 0 taken 2012 times.
✗ Branch 1 not taken.
 2012 if (mi != nullptr) mi->dec_reference();
5256
5257
1/2
✓ Branch 0 taken 2012 times.
✗ Branch 1 not taken.
 2012 gtid_state->end_gtid_wait();
5258
5259
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2011 times.
 2012 return null_result ? error_int() : event_count;
5260 2021 }
5261
5262 /**
5263 Return 1 if both arguments are Gtid_sets and the first is a subset
5264 of the second. Generate an error if any of the arguments is not a
5265 Gtid_set.
5266 */
5267 5892 longlong Item_func_gtid_subset::val_int() {
5268
1/2
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
 5892 DBUG_TRACE;
5269
5270
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5892 times.
 5892 assert(fixed);
5271
5272 5892 null_value = false;
5273
5274 // Evaluate strings without lock
5275
1/2
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
 5892 String *string1 = args[0]->val_str(&buf1);
5276
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5892 times.
 5892 if (string1 == nullptr) {
5277 ✗ return error_int();
5278 }
5279
1/2
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
 5892 String *string2 = args[1]->val_str(&buf2);
5280
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5892 times.
 5892 if (string2 == nullptr) {
5281 ✗ return error_int();
5282 }
5283
5284
1/2
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
 5892 const char *charp1 = string1->c_ptr_safe();
5285
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5892 times.
 5892 assert(charp1 != nullptr);
5286
1/2
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
 5892 const char *charp2 = string2->c_ptr_safe();
5287
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5892 times.
 5892 assert(charp2 != nullptr);
5288 5892 int ret = 1;
5289 enum_return_status status;
5290
5291
1/2
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
 5892 Sid_map sid_map(nullptr /*no rwlock*/);
5292 // compute sets while holding locks
5293
1/2
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
 5892 const Gtid_set sub_set(&sid_map, charp1, &status);
5294
1/2
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
 5892 if (status == RETURN_STATUS_OK) {
5295
1/2
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
 5892 const Gtid_set super_set(&sid_map, charp2, &status);
5296
1/2
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
 5892 if (status == RETURN_STATUS_OK) {
5297
3/4
✓ Branch 0 taken 5892 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5885 times.
✓ Branch 3 taken 7 times.
 5892 ret = sub_set.is_subset(&super_set) ? 1 : 0;
5298 }
5299 5892 }
5300 5892 return ret;
5301 5892 }
5302
5303 /**
5304 Enables a session to wait on a condition until a timeout or a network
5305 disconnect occurs.
5306
5307 @remark The connection is polled every m_interrupt_interval nanoseconds.
5308 */
5309
5310 class Interruptible_wait {
5311 THD *m_thd;
5312 struct timespec m_abs_timeout;
5313 static const ulonglong m_interrupt_interval;
5314
5315 public:
5316 18418 Interruptible_wait(THD *thd) : m_thd(thd) {}
5317
5318 ~Interruptible_wait() = default;
5319
5320 public:
5321 /**
5322 Set the absolute timeout.
5323
5324 @param timeout The amount of time in nanoseconds to wait
5325 */
5326 18404 void set_timeout(ulonglong timeout) {
5327 /*
5328 Calculate the absolute system time at the start so it can
5329 be controlled in slices. It relies on the fact that once
5330 the absolute time passes, the timed wait call will fail
5331 automatically with a timeout error.
5332 */
5333 18404 set_timespec_nsec(&m_abs_timeout, timeout);
5334 18404 }
5335
5336 /** The timed wait. */
5337 int wait(mysql_cond_t *, mysql_mutex_t *);
5338 };
5339
5340 /** Time to wait before polling the connection status. */
5341 const ulonglong Interruptible_wait::m_interrupt_interval = 5 * 1000000000ULL;
5342
5343 /**
5344 Wait for a given condition to be signaled.
5345
5346 @param cond The condition variable to wait on.
5347 @param mutex The associated mutex.
5348
5349 @remark The absolute timeout is preserved across calls.
5350
5351 @retval return value from mysql_cond_timedwait
5352 */
5353
5354 18433 int Interruptible_wait::wait(mysql_cond_t *cond, mysql_mutex_t *mutex) {
5355 int error;
5356 struct timespec timeout;
5357
5358 while (true) {
5359 /* Wait for a fixed interval. */
5360
1/2
✓ Branch 0 taken 18433 times.
✗ Branch 1 not taken.
 18433 set_timespec_nsec(&timeout, m_interrupt_interval);
5361
5362 /* But only if not past the absolute timeout. */
5363
2/2
✓ Branch 0 taken 18375 times.
✓ Branch 1 taken 58 times.
 18433 if (cmp_timespec(&timeout, &m_abs_timeout) > 0) timeout = m_abs_timeout;
5364
5365
1/2
✓ Branch 0 taken 18406 times.
✗ Branch 1 not taken.
 18433 error = mysql_cond_timedwait(cond, mutex, &timeout);
5366
2/2
✓ Branch 0 taken 18375 times.
✓ Branch 1 taken 31 times.
 18406 if (is_timeout(error)) {
5367 /* Return error if timed out or connection is broken. */
5368
7/8
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 18339 times.
✓ Branch 2 taken 36 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 30 times.
✓ Branch 6 taken 18345 times.
✓ Branch 7 taken 30 times.
 18375 if (!cmp_timespec(&timeout, &m_abs_timeout) || !m_thd->is_connected())
5369 18345 break;
5370 }
5371 /* Otherwise, propagate status to the caller. */
5372 else
5373 31 break;
5374 }
5375
5376 18376 return error;
5377 }
5378
5379 /*
5380 User-level locks implementation.
5381 */
5382
5383 /**
5384 For locks with EXPLICIT duration, MDL returns a new ticket
5385 every time a lock is granted. This allows to implement recursive
5386 locks without extra allocation or additional data structures, such
5387 as below. However, if there are too many tickets in the same
5388 MDL_context, MDL_context::find_ticket() is getting too slow,
5389 since it's using a linear search.
5390 This is why a separate structure is allocated for a user
5391 level lock held by connection, and before requesting a new lock from MDL,
5392 GET_LOCK() checks thd->ull_hash if such lock is already granted,
5393 and if so, simply increments a reference counter.
5394 */
5395
5396 struct User_level_lock {
5397 MDL_ticket *ticket;
5398 uint refs;
5399 };
5400
5401 /**
5402 Release all user level locks for this THD.
5403 */
5404
5405 1325839 void mysql_ull_cleanup(THD *thd) {
5406
1/2
✓ Branch 0 taken 1325993 times.
✗ Branch 1 not taken.
 1325839 DBUG_TRACE;
5407
5408
2/2
✓ Branch 0 taken 62 times.
✓ Branch 1 taken 1325920 times.
 1326055 for (const auto &key_and_value : thd->ull_hash) {
5409 62 User_level_lock *ull = key_and_value.second;
5410
1/2
✓ Branch 0 taken 62 times.
✗ Branch 1 not taken.
 62 thd->mdl_context.release_lock(ull->ticket);
5411
1/2
✓ Branch 0 taken 62 times.
✗ Branch 1 not taken.
 62 my_free(ull);
5412 }
5413
5414 1325920 thd->ull_hash.clear();
5415 1325856 }
5416
5417 /**
5418 Set explicit duration for metadata locks corresponding to
5419 user level locks to protect them from being released at the end
5420 of transaction.
5421 */
5422
5423 1 void mysql_ull_set_explicit_lock_duration(THD *thd) {
5424
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 DBUG_TRACE;
5425
5426
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 for (const auto &key_and_value : thd->ull_hash) {
5427 1 User_level_lock *ull = key_and_value.second;
5428
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 thd->mdl_context.set_lock_duration(ull->ticket, MDL_EXPLICIT);
5429 }
5430 1 }
5431
5432 /**
5433 When MDL detects a lock wait timeout, it pushes an error into the statement
5434 diagnostics area. For GET_LOCK(), lock wait timeout is not an error, but a
5435 special return value (0). NULL is returned in case of error. Capture and
5436 suppress lock wait timeout.
5437 We also convert ER_LOCK_DEADLOCK error to ER_USER_LOCK_DEADLOCK error.
5438 The former means that implicit rollback of transaction has occurred
5439 which doesn't (and should not) happen when we get deadlock while waiting
5440 for user-level lock.
5441 */
5442
5443 class User_level_lock_wait_error_handler : public Internal_error_handler {
5444 public:
5445 6451 User_level_lock_wait_error_handler() : m_lock_wait_timeout(false) {}
5446
5447 18 bool got_timeout() const { return m_lock_wait_timeout; }
5448
5449 18 bool handle_condition(THD *, uint sql_errno, const char *,
5450 Sql_condition::enum_severity_level *,
5451 const char *) override {
5452
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.
 18 if (sql_errno == ER_LOCK_WAIT_TIMEOUT) {
5453 9 m_lock_wait_timeout = true;
5454 9 return true;
5455
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 } else if (sql_errno == ER_LOCK_DEADLOCK) {
5456 ✗ my_error(ER_USER_LOCK_DEADLOCK, MYF(0));
5457 ✗ return true;
5458 }
5459
5460 9 return false;
5461 }
5462
5463 private:
5464 bool m_lock_wait_timeout;
5465 };
5466
5467 class MDL_lock_get_owner_thread_id_visitor : public MDL_context_visitor {
5468 public:
5469 73 MDL_lock_get_owner_thread_id_visitor() : m_owner_id(0) {}
5470
5471 27 void visit_context(const MDL_context *ctx) override {
5472 27 m_owner_id = ctx->get_owner()->get_thd()->thread_id();
5473 27 }
5474
5475 73 my_thread_id get_owner_id() const { return m_owner_id; }
5476
5477 private:
5478 my_thread_id m_owner_id;
5479 };
5480
5481 /**
5482 Helper function which checks if user-level lock name is acceptable
5483 and converts it to system charset (utf8). Error is emitted if name
5484 is not acceptable. Name is also lowercased to ensure that user-level
5485 lock names are treated in case-insensitive fashion even though MDL
5486 subsystem which used by implementation does binary comparison of keys.
5487
5488 @param buff Buffer for lowercased name in system charset of
5489 NAME_LEN + 1 bytes length.
5490 @param org_name Original string passed as name parameter to
5491 user-level lock function.
5492
5493 @return True in case of error, false on success.
5494 */
5495
5496 12924 static bool check_and_convert_ull_name(char *buff, const String *org_name) {
5497
3/6
✓ Branch 0 taken 12924 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12924 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 12924 times.
 12924 if (!org_name || !org_name->length()) {
5498 ✗ my_error(ER_USER_LOCK_WRONG_NAME, MYF(0), (org_name ? "" : "NULL"));
5499 ✗ return true;
5500 }
5501
5502 const char *well_formed_error_pos;
5503 const char *cannot_convert_error_pos;
5504 const char *from_end_pos;
5505 size_t bytes_copied;
5506
5507
1/2
✓ Branch 0 taken 12924 times.
✗ Branch 1 not taken.
 12924 bytes_copied = well_formed_copy_nchars(
5508 system_charset_info, buff, NAME_LEN, org_name->charset(), org_name->ptr(),
5509 org_name->length(), NAME_CHAR_LEN, &well_formed_error_pos,
5510 &cannot_convert_error_pos, &from_end_pos);
5511
5512
3/6
✓ Branch 0 taken 12924 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12924 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 12924 times.
 25848 if (well_formed_error_pos || cannot_convert_error_pos ||
5513
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12924 times.
 12924 from_end_pos < org_name->ptr() + org_name->length()) {
5514 ✗ ErrConvString err(org_name);
5515 ✗ my_error(ER_USER_LOCK_WRONG_NAME, MYF(0), err.ptr());
5516 ✗ return true;
5517 }
5518
5519 12924 buff[bytes_copied] = '\0';
5520
5521
1/2
✓ Branch 0 taken 12924 times.
✗ Branch 1 not taken.
 12924 my_casedn_str(system_charset_info, buff);
5522
5523 12924 return false;
5524 }
5525
5526 7106 bool Item_func_get_lock::itemize(Parse_context *pc, Item **res) {
5527
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7106 times.
 7106 if (skip_itemize(res)) return false;
5528
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7106 times.
 7106 if (super::itemize(pc, res)) return true;
5529 7106 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
5530 7106 pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT);
5531 7106 return false;
5532 }
5533
5534 /**
5535 Get a user level lock.
5536
5537 @note Sets null_value to true on error.
5538
5539 @note This means that SQL-function GET_LOCK() returns:
5540 1 - if lock was acquired.
5541 0 - if lock was not acquired due to timeout.
5542 NULL - in case of error such as bad lock name, deadlock,
5543 thread being killed (also error is emitted).
5544
5545 @retval
5546 1 : Got lock
5547 @retval
5548 0 : Timeout, error.
5549 */
5550
5551 6486 longlong Item_func_get_lock::val_int() {
5552
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6486 times.
 6486 assert(fixed == 1);
5553
1/2
✓ Branch 0 taken 6486 times.
✗ Branch 1 not taken.
 6486 String *res = args[0]->val_str(&value);
5554
1/2
✓ Branch 0 taken 6486 times.
✗ Branch 1 not taken.
 6486 ulonglong timeout = args[1]->val_int();
5555 char name[NAME_LEN + 1];
5556
1/2
✓ Branch 0 taken 6486 times.
✗ Branch 1 not taken.
 6486 THD *thd = current_thd;
5557
1/2
✓ Branch 0 taken 6486 times.
✗ Branch 1 not taken.
 6486 DBUG_TRACE;
5558
5559 6486 null_value = true;
5560 /*
5561 In slave thread no need to get locks, everything is serialized. Anyway
5562 there is no way to make GET_LOCK() work on slave like it did on master
5563 (i.e. make it return exactly the same value) because we don't have the
5564 same other concurrent threads environment. No matter what we return here,
5565 it's not guaranteed to be same as on master. So we always return 1.
5566 */
5567
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 6473 times.
 6486 if (thd->slave_thread) {
5568 13 null_value = false;
5569 13 return 1;
5570 }
5571
5572
2/4
✓ Branch 0 taken 6473 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6473 times.
 6473 if (check_and_convert_ull_name(name, res)) return 0;
5573
5574
3/8
✓ Branch 0 taken 6473 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6473 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6473 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 6473 DBUG_PRINT("info", ("lock %s, thd=%lu", name, (ulong)thd->real_id));
5575
5576 /*
5577 Convert too big and negative timeout values to INT_MAX32.
5578 This gives robust, "infinite" wait on all platforms.
5579 */
5580
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6473 times.
 6473 if (timeout > INT_MAX32) timeout = INT_MAX32;
5581
5582 6473 MDL_request ull_request;
5583
1/2
✓ Branch 0 taken 6473 times.
✗ Branch 1 not taken.
 6473 MDL_REQUEST_INIT(&ull_request, MDL_key::USER_LEVEL_LOCK, "", name,
5584 MDL_EXCLUSIVE, MDL_EXPLICIT);
5585 12946 std::string ull_key(pointer_cast<const char *>(ull_request.key.ptr()),
5586
2/4
✓ Branch 0 taken 6473 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6473 times.
✗ Branch 3 not taken.
 6473 ull_request.key.length());
5587
5588
1/2
✓ Branch 0 taken 6473 times.
✗ Branch 1 not taken.
 6473 const auto it = thd->ull_hash.find(ull_key);
5589
2/2
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 6451 times.
 6473 if (it != thd->ull_hash.end()) {
5590 /* Recursive lock. */
5591 22 it->second->refs++;
5592 22 null_value = false;
5593 22 return 1;
5594 }
5595
5596 6451 User_level_lock_wait_error_handler error_handler;
5597
5598
1/2
✓ Branch 0 taken 6451 times.
✗ Branch 1 not taken.
 6451 thd->push_internal_handler(&error_handler);
5599 bool error =
5600
1/2
✓ Branch 0 taken 6451 times.
✗ Branch 1 not taken.
 6451 thd->mdl_context.acquire_lock(&ull_request, static_cast<ulong>(timeout));
5601
1/2
✓ Branch 0 taken 6451 times.
✗ Branch 1 not taken.
 6451 (void)thd->pop_internal_handler();
5602
5603
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 6433 times.
 6451 if (error) {
5604 /*
5605 Return 0 in case of timeout and NULL in case of deadlock/other
5606 errors. In the latter case error (e.g. ER_USER_LOCK_DEADLOCK)
5607 will be reported as well.
5608 */
5609
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.
 18 if (error_handler.got_timeout()) null_value = false;
5610 18 return 0;
5611 }
5612
5613 6433 User_level_lock *ull = nullptr;
5614 6433 ull = reinterpret_cast<User_level_lock *>(
5615
1/2
✓ Branch 0 taken 6433 times.
✗ Branch 1 not taken.
 6433 my_malloc(key_memory_User_level_lock, sizeof(User_level_lock), MYF(0)));
5616
5617
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6433 times.
 6433 if (ull == nullptr) {
5618 ✗ thd->mdl_context.release_lock(ull_request.ticket);
5619 ✗ return 0;
5620 }
5621
5622 6433 ull->ticket = ull_request.ticket;
5623 6433 ull->refs = 1;
5624
5625
1/2
✓ Branch 0 taken 6433 times.
✗ Branch 1 not taken.
 6433 thd->ull_hash.emplace(ull_key, ull);
5626 6433 null_value = false;
5627
5628 6433 return 1;
5629 6486 }
5630
5631 6980 bool Item_func_release_lock::itemize(Parse_context *pc, Item **res) {
5632
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6980 times.
 6980 if (skip_itemize(res)) return false;
5633
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6980 times.
 6980 if (super::itemize(pc, res)) return true;
5634 6980 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
5635 6980 pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT);
5636 6980 return false;
5637 }
5638
5639 /**
5640 Release a user level lock.
5641
5642 @note Sets null_value to true on error/if no connection holds such lock.
5643
5644 @note This means that SQL-function RELEASE_LOCK() returns:
5645 1 - if lock was held by this connection and was released.
5646 0 - if lock was held by some other connection (and was not released).
5647 NULL - if name of lock is bad or if it was not held by any connection
5648 (in the former case also error will be emitted),
5649
5650 @return
5651 - 1 if lock released
5652 - 0 if lock wasn't held/error.
5653 */
5654
5655 6384 longlong Item_func_release_lock::val_int() {
5656
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6384 times.
 6384 assert(fixed == 1);
5657
1/2
✓ Branch 0 taken 6384 times.
✗ Branch 1 not taken.
 6384 String *res = args[0]->val_str(&value);
5658 char name[NAME_LEN + 1];
5659
1/2
✓ Branch 0 taken 6384 times.
✗ Branch 1 not taken.
 6384 THD *thd = current_thd;
5660
1/2
✓ Branch 0 taken 6384 times.
✗ Branch 1 not taken.
 6384 DBUG_TRACE;
5661
5662 6384 null_value = true;
5663
5664
2/4
✓ Branch 0 taken 6384 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6384 times.
 6384 if (check_and_convert_ull_name(name, res)) return 0;
5665
5666
3/8
✓ Branch 0 taken 6384 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6384 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6384 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 6384 DBUG_PRINT("info", ("lock %s", name));
5667
5668 6384 MDL_key ull_key;
5669
1/2
✓ Branch 0 taken 6384 times.
✗ Branch 1 not taken.
 6384 ull_key.mdl_key_init(MDL_key::USER_LEVEL_LOCK, "", name);
5670
5671
1/2
✓ Branch 0 taken 6384 times.
✗ Branch 1 not taken.
 6384 const auto it = thd->ull_hash.find(
5672
2/4
✓ Branch 0 taken 6384 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6384 times.
✗ Branch 3 not taken.
 12768 std::string(pointer_cast<const char *>(ull_key.ptr()), ull_key.length()));
5673
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6378 times.
 6384 if (it == thd->ull_hash.end()) {
5674 /*
5675 When RELEASE_LOCK() is called for lock which is not owned by the
5676 connection it should return 0 or NULL depending on whether lock
5677 is owned by any other connection or not.
5678 */
5679 6 MDL_lock_get_owner_thread_id_visitor get_owner_visitor;
5680
5681
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
 6 if (thd->mdl_context.find_lock_owner(&ull_key, &get_owner_visitor))
5682 ✗ return 0;
5683
5684 6 null_value = get_owner_visitor.get_owner_id() == 0;
5685
5686 6 return 0;
5687 6 }
5688 6378 User_level_lock *ull = it->second;
5689
5690 6378 null_value = false;
5691
2/2
✓ Branch 0 taken 6371 times.
✓ Branch 1 taken 7 times.
 6378 if (--ull->refs == 0) {
5692
1/2
✓ Branch 0 taken 6371 times.
✗ Branch 1 not taken.
 6371 thd->ull_hash.erase(it);
5693
1/2
✓ Branch 0 taken 6371 times.
✗ Branch 1 not taken.
 6371 thd->mdl_context.release_lock(ull->ticket);
5694
1/2
✓ Branch 0 taken 6371 times.
✗ Branch 1 not taken.
 6371 my_free(ull);
5695 }
5696 6378 return 1;
5697 6384 }
5698
5699 9 bool Item_func_release_all_locks::itemize(Parse_context *pc, Item **res) {
5700
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (skip_itemize(res)) return false;
5701
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (super::itemize(pc, res)) return true;
5702 9 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
5703 9 pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT);
5704 9 return false;
5705 }
5706
5707 /**
5708 Release all user level lock held by connection.
5709
5710 @return Number of locks released including recursive lock count.
5711 */
5712
5713 5 longlong Item_func_release_all_locks::val_int() {
5714
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 assert(fixed == 1);
5715
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 THD *thd = current_thd;
5716 5 uint result = 0;
5717
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 DBUG_TRACE;
5718
5719
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 for (const auto &key_and_value : thd->ull_hash) {
5720 ✗ User_level_lock *ull = key_and_value.second;
5721 ✗ thd->mdl_context.release_lock(ull->ticket);
5722 ✗ result += ull->refs;
5723 ✗ my_free(ull);
5724 }
5725 5 thd->ull_hash.clear();
5726
5727 5 return result;
5728 5 }
5729
5730 48 bool Item_func_is_free_lock::itemize(Parse_context *pc, Item **res) {
5731
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
 48 if (skip_itemize(res)) return false;
5732
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
 48 if (super::itemize(pc, res)) return true;
5733 48 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
5734 48 pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT);
5735 48 return false;
5736 }
5737
5738 /**
5739 Check if user level lock is free.
5740
5741 @note Sets null_value=true on error.
5742
5743 @note As result SQL-function IS_FREE_LOCK() returns:
5744 1 - if lock is free,
5745 0 - if lock is in use
5746 NULL - if lock name is bad or OOM (also error is emitted).
5747
5748 @retval
5749 1 Available
5750 @retval
5751 0 Already taken, or error
5752 */
5753
5754 39 longlong Item_func_is_free_lock::val_int() {
5755
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
 39 assert(fixed == 1);
5756 39 value.length(0);
5757
1/2
✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
 39 String *res = args[0]->val_str(&value);
5758 char name[NAME_LEN + 1];
5759
1/2
✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
 39 THD *thd = current_thd;
5760
5761 39 null_value = true;
5762
5763
2/4
✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 39 times.
 39 if (check_and_convert_ull_name(name, res)) return 0;
5764
5765 39 MDL_key ull_key;
5766
1/2
✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
 39 ull_key.mdl_key_init(MDL_key::USER_LEVEL_LOCK, "", name);
5767
5768 39 MDL_lock_get_owner_thread_id_visitor get_owner_visitor;
5769
5770
2/4
✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 39 times.
 39 if (thd->mdl_context.find_lock_owner(&ull_key, &get_owner_visitor)) return 0;
5771
5772 39 null_value = false;
5773 39 return (get_owner_visitor.get_owner_id() == 0);
5774 39 }
5775
5776 620 bool Item_func_is_used_lock::itemize(Parse_context *pc, Item **res) {
5777
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 620 times.
 620 if (skip_itemize(res)) return false;
5778
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 620 times.
 620 if (super::itemize(pc, res)) return true;
5779 620 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
5780 620 pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT);
5781 620 return false;
5782 }
5783
5784 /**
5785 Check if user level lock is used and return connection id of owner.
5786
5787 @note Sets null_value=true if lock is free/on error.
5788
5789 @note SQL-function IS_USED_LOCK() returns:
5790 # - connection id of lock owner if lock is acquired.
5791 NULL - if lock is free or on error (in the latter case
5792 also error is emitted).
5793
5794 @return Connection id of lock owner, 0 if lock is free/on error.
5795 */
5796
5797 28 longlong Item_func_is_used_lock::val_int() {
5798
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
 28 assert(fixed == 1);
5799
1/2
✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
 28 String *res = args[0]->val_str(&value);
5800 char name[NAME_LEN + 1];
5801
1/2
✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
 28 THD *thd = current_thd;
5802
5803 28 null_value = true;
5804
5805
2/4
✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 28 times.
 28 if (check_and_convert_ull_name(name, res)) return 0;
5806
5807 28 MDL_key ull_key;
5808
1/2
✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
 28 ull_key.mdl_key_init(MDL_key::USER_LEVEL_LOCK, "", name);
5809
5810 28 MDL_lock_get_owner_thread_id_visitor get_owner_visitor;
5811
5812
2/4
✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 28 times.
 28 if (thd->mdl_context.find_lock_owner(&ull_key, &get_owner_visitor)) return 0;
5813
5814 28 my_thread_id thread_id = get_owner_visitor.get_owner_id();
5815
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 13 times.
 28 if (thread_id == 0) return 0;
5816
5817 13 null_value = false;
5818 13 return thread_id;
5819 28 }
5820
5821 1374 bool Item_func_last_insert_id::itemize(Parse_context *pc, Item **res) {
5822
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1374 times.
 1374 if (skip_itemize(res)) return false;
5823
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1374 times.
 1374 if (super::itemize(pc, res)) return true;
5824 1374 pc->thd->lex->safe_to_cache_query = false;
5825 1374 pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT);
5826 1374 return false;
5827 }
5828
5829 1855 longlong Item_func_last_insert_id::val_int() {
5830 1855 THD *thd = current_thd;
5831
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1855 times.
 1855 assert(fixed == 1);
5832
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 1837 times.
 1855 if (arg_count) {
5833 18 longlong value = args[0]->val_int();
5834 18 null_value = args[0]->null_value;
5835 /*
5836 LAST_INSERT_ID(X) must affect the client's mysql_insert_id() as
5837 documented in the manual. We don't want to touch
5838 first_successful_insert_id_in_cur_stmt because it would make
5839 LAST_INSERT_ID(X) take precedence over an generated auto_increment
5840 value for this row.
5841 */
5842 18 thd->arg_of_last_insert_id_function = true;
5843 18 thd->first_successful_insert_id_in_prev_stmt = value;
5844 18 return value;
5845 }
5846 return static_cast<longlong>(
5847 1837 thd->read_first_successful_insert_id_in_prev_stmt());
5848 }
5849
5850 34 bool Item_func_benchmark::itemize(Parse_context *pc, Item **res) {
5851
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
 34 if (skip_itemize(res)) return false;
5852
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
 34 if (super::itemize(pc, res)) return true;
5853 34 pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT);
5854 34 return false;
5855 }
5856
5857 /* This function is just used to test speed of different functions */
5858
5859 32 longlong Item_func_benchmark::val_int() {
5860
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
 32 assert(fixed == 1);
5861 char buff[MAX_FIELD_WIDTH];
5862 32 String tmp(buff, sizeof(buff), &my_charset_bin);
5863 32 my_decimal tmp_decimal;
5864
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 THD *thd = current_thd;
5865 ulonglong loop_count;
5866
5867
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 loop_count = (ulonglong)args[0]->val_int();
5868
5869
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 2 times.
 32 if (args[0]->null_value ||
5870
3/4
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 29 times.
 30 (!args[0]->unsigned_flag && (((longlong)loop_count) < 0))) {
5871
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
 3 if (!args[0]->null_value) {
5872 char errbuff[22];
5873
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 llstr(((longlong)loop_count), errbuff);
5874
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 push_warning_printf(current_thd, Sql_condition::SL_WARNING,
5875 ER_WRONG_VALUE_FOR_TYPE,
5876
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 ER_THD(current_thd, ER_WRONG_VALUE_FOR_TYPE), "count",
5877 errbuff, "benchmark");
5878 }
5879
5880 3 null_value = true;
5881 3 return 0;
5882 }
5883
5884 29 null_value = false;
5885
5/6
✓ Branch 0 taken 1440 times.
✓ Branch 1 taken 29 times.
✓ Branch 2 taken 1440 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1440 times.
✓ Branch 5 taken 29 times.
 1469 for (ulonglong loop = 0; loop < loop_count && !thd->killed; loop++) {
5886
5/7
✓ Branch 0 taken 1440 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 40 times.
✓ Branch 3 taken 1000 times.
✓ Branch 4 taken 100 times.
✓ Branch 5 taken 300 times.
✗ Branch 6 not taken.
 1440 switch (args[1]->result_type()) {
5887 40 case REAL_RESULT:
5888
1/2
✓ Branch 0 taken 40 times.
✗ Branch 1 not taken.
 40 (void)args[1]->val_real();
5889 40 break;
5890 1000 case INT_RESULT:
5891
1/2
✓ Branch 0 taken 1000 times.
✗ Branch 1 not taken.
 1000 (void)args[1]->val_int();
5892 1000 break;
5893 100 case STRING_RESULT:
5894
1/2
✓ Branch 0 taken 100 times.
✗ Branch 1 not taken.
 100 (void)args[1]->val_str(&tmp);
5895 100 break;
5896 300 case DECIMAL_RESULT:
5897
1/2
✓ Branch 0 taken 300 times.
✗ Branch 1 not taken.
 300 (void)args[1]->val_decimal(&tmp_decimal);
5898 300 break;
5899 ✗ case ROW_RESULT:
5900 default:
5901 // This case should never be chosen
5902 ✗ assert(0);
5903 return 0;
5904 }
5905 }
5906 29 return 0;
5907 32 }
5908
5909 1 void Item_func_benchmark::print(const THD *thd, String *str,
5910 enum_query_type query_type) const {
5911 1 str->append(STRING_WITH_LEN("benchmark("));
5912 1 args[0]->print(thd, str, query_type);
5913 1 str->append(',');
5914 1 args[1]->print(thd, str, query_type);
5915 1 str->append(')');
5916 1 }
5917
5918 /**
5919 Lock which is used to implement interruptible wait for SLEEP() function.
5920 */
5921
5922 mysql_mutex_t LOCK_item_func_sleep;
5923
5924 #ifdef HAVE_PSI_INTERFACE
5925 static PSI_mutex_key key_LOCK_item_func_sleep;
5926
5927 static PSI_mutex_info item_func_sleep_mutexes[] = {
5928 {&key_LOCK_item_func_sleep, "LOCK_item_func_sleep", PSI_FLAG_SINGLETON, 0,
5929 PSI_DOCUMENT_ME}};
5930
5931 12108 static void init_item_func_sleep_psi_keys() {
5932 int count;
5933
5934 12108 count = static_cast<int>(array_elements(item_func_sleep_mutexes));
5935 12108 mysql_mutex_register("sql", item_func_sleep_mutexes, count);
5936 12108 }
5937 #endif
5938
5939 static bool item_func_sleep_inited = false;
5940
5941 12108 void item_func_sleep_init() {
5942 #ifdef HAVE_PSI_INTERFACE
5943 12108 init_item_func_sleep_psi_keys();
5944 #endif
5945
5946 12108 mysql_mutex_init(key_LOCK_item_func_sleep, &LOCK_item_func_sleep,
5947 MY_MUTEX_INIT_SLOW);
5948 12108 item_func_sleep_inited = true;
5949 12108 }
5950
5951 10524 void item_func_sleep_free() {
5952
2/2
✓ Branch 0 taken 10490 times.
✓ Branch 1 taken 34 times.
 10524 if (item_func_sleep_inited) {
5953 10490 item_func_sleep_inited = false;
5954 10490 mysql_mutex_destroy(&LOCK_item_func_sleep);
5955 }
5956 10524 }
5957
5958 16072 bool Item_func_sleep::itemize(Parse_context *pc, Item **res) {
5959
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16073 times.
 16072 if (skip_itemize(res)) return false;
5960
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16072 times.
 16073 if (super::itemize(pc, res)) return true;
5961 16072 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
5962 16073 pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT);
5963 16073 return false;
5964 }
5965
5966 /** This function is just used to create tests with time gaps. */
5967
5968 18418 longlong Item_func_sleep::val_int() {
5969
1/2
✓ Branch 0 taken 18418 times.
✗ Branch 1 not taken.
 18418 THD *thd = current_thd;
5970 18418 Interruptible_wait timed_cond(thd);
5971 mysql_cond_t cond;
5972 double timeout;
5973 int error;
5974
5975
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18418 times.
 18418 assert(fixed == 1);
5976
5977
1/2
✓ Branch 0 taken 18418 times.
✗ Branch 1 not taken.
 18418 timeout = args[0]->val_real();
5978
5979 /*
5980 Report error or warning depending on the value of SQL_MODE.
5981 If SQL is STRICT then report error, else report warning and continue
5982 execution.
5983 */
5984
5985
3/4
✓ Branch 0 taken 18416 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 18416 times.
 18418 if (args[0]->null_value || timeout < 0) {
5986
5/6
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 1 times.
 2 if (!thd->lex->is_ignore() && thd->is_strict_mode()) {
5987
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 my_error(ER_WRONG_ARGUMENTS, MYF(0), "sleep.");
5988 1 return 0;
5989 } else
5990
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 push_warning_printf(thd, Sql_condition::SL_WARNING, ER_WRONG_ARGUMENTS,
5991 ER_THD(thd, ER_WRONG_ARGUMENTS), "sleep.");
5992 }
5993 /*
5994 On 64-bit OSX mysql_cond_timedwait() waits forever
5995 if passed abstime time has already been exceeded by
5996 the system time.
5997 When given a very short timeout (< 10 mcs) just return
5998 immediately.
5999 We assume that the lines between this test and the call
6000 to mysql_cond_timedwait() will be executed in less than 0.00001 sec.
6001 */
6002
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 18404 times.
 18417 if (timeout < 0.00001) return 0;
6003
6004
1/2
✓ Branch 0 taken 18404 times.
✗ Branch 1 not taken.
 18404 timed_cond.set_timeout((ulonglong)(timeout * 1000000000.0));
6005
6006
1/2
✓ Branch 0 taken 18404 times.
✗ Branch 1 not taken.
 18404 mysql_cond_init(key_item_func_sleep_cond, &cond);
6007
1/2
✓ Branch 0 taken 18403 times.
✗ Branch 1 not taken.
 18404 mysql_mutex_lock(&LOCK_item_func_sleep);
6008
6009
1/2
✓ Branch 0 taken 18403 times.
✗ Branch 1 not taken.
 18403 thd->ENTER_COND(&cond, &LOCK_item_func_sleep, &stage_user_sleep, nullptr);
6010
6011
3/6
✓ Branch 0 taken 18403 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18403 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 18403 times.
✗ Branch 5 not taken.
 18403 DEBUG_SYNC(current_thd, "func_sleep_before_sleep");
6012
6013 18403 error = 0;
6014
1/2
✓ Branch 0 taken 18403 times.
✗ Branch 1 not taken.
 18403 thd_wait_begin(thd, THD_WAIT_SLEEP);
6015
2/2
✓ Branch 0 taken 18403 times.
✓ Branch 1 taken 31 times.
 18434 while (!thd->killed) {
6016
1/2
✓ Branch 0 taken 18376 times.
✗ Branch 1 not taken.
 18403 error = timed_cond.wait(&cond, &LOCK_item_func_sleep);
6017
2/2
✓ Branch 0 taken 18345 times.
✓ Branch 1 taken 31 times.
 18376 if (is_timeout(error)) break;
6018 31 error = 0;
6019 }
6020
1/2
✓ Branch 0 taken 18376 times.
✗ Branch 1 not taken.
 18376 thd_wait_end(thd);
6021
1/2
✓ Branch 0 taken 18376 times.
✗ Branch 1 not taken.
 18376 mysql_mutex_unlock(&LOCK_item_func_sleep);
6022
1/2
✓ Branch 0 taken 18376 times.
✗ Branch 1 not taken.
 18376 thd->EXIT_COND(nullptr);
6023
6024
1/2
✓ Branch 0 taken 18376 times.
✗ Branch 1 not taken.
 18376 mysql_cond_destroy(&cond);
6025
6026 18376 return (error == 0); // Return 1 killed
6027 }
6028
6029 /**
6030 Get variable with given name; conditionally create it if non-existing
6031
6032 @param thd thread context
6033 @param name name of user variable
6034 @param cs character set;
6035 = NULL: Do not create variable if non-existing.
6036 != NULL: Create variable with this character set.
6037
6038 @returns pointer to variable entry.
6039 = NULL: variable does not exist (if cs == NULL), or
6040 could not create variable (if cs != NULL)
6041 */
6042 3545537 static user_var_entry *get_variable(THD *thd, const Name_string &name,
6043 const CHARSET_INFO *cs) {
6044
1/2
✓ Branch 0 taken 3545540 times.
✗ Branch 1 not taken.
 3545537 const std::string key(name.ptr(), name.length());
6045
6046 /* Protects thd->user_vars. */
6047 3545541 mysql_mutex_assert_owner(&thd->LOCK_thd_data);
6048
6049
1/2
✓ Branch 0 taken 3545539 times.
✗ Branch 1 not taken.
 3545548 user_var_entry *entry = find_or_nullptr(thd->user_vars, key);
6050
4/4
✓ Branch 0 taken 197599 times.
✓ Branch 1 taken 3347940 times.
✓ Branch 2 taken 180845 times.
✓ Branch 3 taken 16754 times.
 3545539 if (entry == nullptr && cs != nullptr) {
6051
1/2
✓ Branch 0 taken 180845 times.
✗ Branch 1 not taken.
 180845 entry = user_var_entry::create(thd, name, cs);
6052
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 180845 times.
 180845 if (entry == nullptr) return nullptr;
6053
1/2
✓ Branch 0 taken 180844 times.
✗ Branch 1 not taken.
 180845 thd->user_vars.emplace(
6054 361689 key, unique_ptr_with_deleter<user_var_entry>(entry, &free_user_var));
6055 }
6056 3545539 return entry;
6057 3545539 }
6058
6059 981947 void Item_func_set_user_var::cleanup() {
6060 981947 Item_func::cleanup();
6061 /*
6062 Ensure that a valid user variable object is rebound on next
6063 execution. This is important if the user variable is referenced by a
6064 trigger: the trigger references an Item_func_set_user_var, and may be
6065 used by another THD in the future (the trigger is cached in a TABLE). When
6066 that later happens, the other THD will use the same Item_func_set_user_var
6067 but shouldn't try to access the previous THD's entry. So we clear it here,
6068 and set it again later in Item_func_set_user_var::update().
6069 */
6070 981949 entry = nullptr;
6071 981949 }
6072
6073 1644101 bool Item_func_set_user_var::set_entry(THD *thd, bool create_if_not_exists) {
6074
2/2
✓ Branch 0 taken 1641559 times.
✓ Branch 1 taken 2542 times.
 1644101 if (entry == nullptr) {
6075 const CHARSET_INFO *cs =
6076 create_if_not_exists
6077
2/2
✓ Branch 0 taken 1636737 times.
✓ Branch 1 taken 4822 times.
 3278297 ? (args[0]->collation.derivation == DERIVATION_NUMERIC
6078
2/2
✓ Branch 0 taken 1117374 times.
✓ Branch 1 taken 519363 times.
 1636737 ? default_charset()
6079 519363 : args[0]->collation.collation)
6080 1641560 : nullptr;
6081
6082 /* Protects thd->user_vars. */
6083 1641560 mysql_mutex_lock(&thd->LOCK_thd_data);
6084 1641561 entry = get_variable(thd, name, cs);
6085 1641558 mysql_mutex_unlock(&thd->LOCK_thd_data);
6086
6087
2/2
✓ Branch 0 taken 403 times.
✓ Branch 1 taken 1641158 times.
 1641561 if (entry == nullptr) return true;
6088 }
6089
6090 // Ensure this user variable is owned by the current session
6091
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1643698 times.
 1643700 assert(entry->owner_session() == thd);
6092
6093 1643698 return false;
6094 }
6095
6096 /*
6097 When a user variable is updated (in a SET command or a query like
6098 SELECT @a:= ).
6099 */
6100
6101 660412 bool Item_func_set_user_var::fix_fields(THD *thd, Item **ref) {
6102
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 660412 times.
 660412 assert(!fixed);
6103
6104
2/2
✓ Branch 0 taken 199 times.
✓ Branch 1 taken 660213 times.
 660412 if (Item_func::fix_fields(thd, ref)) return true;
6105
6106 // This is probably only to get an early validity check on user variable name
6107
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 660212 times.
 660213 if (set_entry(thd, true)) return true;
6108 660212 entry = nullptr;
6109
6110 660212 null_item = (args[0]->type() == NULL_ITEM);
6111
6112 660213 return false;
6113 }
6114
6115 660213 bool Item_func_set_user_var::resolve_type(THD *thd) {
6116
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 660213 times.
 660213 if (Item_var_func::resolve_type(thd)) return true;
6117 660213 set_nullable(args[0]->is_nullable());
6118 660213 collation.set(DERIVATION_IMPLICIT);
6119 /*
6120 this sets the character set of the item immediately; rules for the
6121 character set of the variable ("entry" object) are different: if "entry"
6122 did not exist previously, set_entry () has created it and has set its
6123 character set; but if it existed previously, it keeps its previous
6124 character set, which may change only when we are sure that the assignment
6125 is to be executed, i.e. in user_var_entry::store ().
6126 */
6127
2/2
✓ Branch 0 taken 443331 times.
✓ Branch 1 taken 216882 times.
 660213 if (args[0]->collation.derivation == DERIVATION_NUMERIC)
6128 443331 collation.collation = default_charset();
6129 else
6130 216882 collation.collation = args[0]->collation.collation;
6131
6132 660213 enum_field_types type = Item::type_for_variable(args[0]->data_type());
6133
4/5
✓ Branch 0 taken 425820 times.
✓ Branch 1 taken 3251 times.
✓ Branch 2 taken 14106 times.
✓ Branch 3 taken 217036 times.
✗ Branch 4 not taken.
 660213 switch (type) {
6134 425820 case MYSQL_TYPE_LONGLONG:
6135 425820 set_data_type_longlong();
6136 425820 unsigned_flag = args[0]->unsigned_flag;
6137 425820 max_length =
6138 425820 args[0]->max_length; // Preserves "length" of integer constants
6139 425820 break;
6140 3251 case MYSQL_TYPE_NEWDECIMAL:
6141 3251 set_data_type_decimal(args[0]->decimal_precision(), args[0]->decimals);
6142 3251 break;
6143 14106 case MYSQL_TYPE_DOUBLE:
6144 14106 set_data_type_double();
6145 14106 break;
6146 217036 case MYSQL_TYPE_VARCHAR:
6147 217036 set_data_type_string(args[0]->max_char_length());
6148 217036 break;
6149 ✗ case MYSQL_TYPE_NULL:
6150 default:
6151 ✗ assert(false);
6152 set_data_type(MYSQL_TYPE_NULL);
6153 break;
6154 }
6155
6156 660213 cached_result_type = Item::type_to_result(data_type());
6157
6158 660213 return false;
6159 }
6160
6161 // static
6162 180845 user_var_entry *user_var_entry::create(THD *thd, const Name_string &name,
6163 const CHARSET_INFO *cs) {
6164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 180845 times.
 180845 if (check_column_name(name.ptr())) {
6165 ✗ my_error(ER_ILLEGAL_USER_VAR, MYF(0), name.ptr());
6166 ✗ return nullptr;
6167 }
6168
6169 user_var_entry *entry;
6170 size_t size =
6171 180845 ALIGN_SIZE(sizeof(user_var_entry)) + (name.length() + 1) + extra_size;
6172
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 180845 times.
 180845 if (!(entry = (user_var_entry *)my_malloc(key_memory_user_var_entry, size,
6173 MYF(MY_WME | ME_FATALERROR))))
6174 ✗ return nullptr;
6175 180845 entry->init(thd, name, cs);
6176 180845 return entry;
6177 }
6178
6179 3376577 bool user_var_entry::mem_realloc(size_t length) {
6180
2/2
✓ Branch 0 taken 3075365 times.
✓ Branch 1 taken 301212 times.
 3376577 if (length <= extra_size) {
6181 /* Enough space to store value in value struct */
6182 3075365 free_value();
6183 3075368 m_ptr = internal_buffer_ptr();
6184 } else {
6185 /* Allocate an external buffer */
6186
2/2
✓ Branch 0 taken 297175 times.
✓ Branch 1 taken 4037 times.
 301212 if (m_length != length) {
6187
2/2
✓ Branch 0 taken 8499 times.
✓ Branch 1 taken 288676 times.
 297175 if (m_ptr == internal_buffer_ptr()) m_ptr = nullptr;
6188
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 297175 times.
 297175 if (!(m_ptr = (char *)my_realloc(
6189 297175 key_memory_user_var_entry_value, m_ptr, length,
6190 MYF(MY_ALLOW_ZERO_PTR | MY_WME | ME_FATALERROR))))
6191 ✗ return true;
6192 }
6193 }
6194 3376580 return false;
6195 }
6196
6197 180845 void user_var_entry::init(THD *thd, const Simple_cstring &name,
6198 const CHARSET_INFO *cs) {
6199
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 180845 times.
 180845 assert(thd != nullptr);
6200 180845 m_owner = thd;
6201 180845 copy_name(name);
6202 180845 reset_value();
6203 180845 m_used_query_id = 0;
6204 180845 collation.set(cs, DERIVATION_IMPLICIT, 0);
6205 180845 unsigned_flag = false;
6206 180845 m_type = STRING_RESULT;
6207 180845 }
6208
6209 3376577 bool user_var_entry::store(const void *from, size_t length, Item_result type) {
6210 3376577 assert_locked();
6211
6212 // Store strings with end \0
6213
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3376580 times.
 3376580 if (mem_realloc(length + (type == STRING_RESULT))) return true;
6214
2/2
✓ Branch 0 taken 353305 times.
✓ Branch 1 taken 3023275 times.
 3376580 if (type == STRING_RESULT) m_ptr[length] = 0; // Store end \0
6215
6216 // Avoid memcpy of a my_decimal object, use copy CTOR instead.
6217
2/2
✓ Branch 0 taken 2574 times.
✓ Branch 1 taken 3374006 times.
 3376580 if (type == DECIMAL_RESULT) {
6218
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2574 times.
 2574 assert(length == sizeof(my_decimal));
6219 2574 const my_decimal *dec = static_cast<const my_decimal *>(from);
6220 2574 dec->sanity_check();
6221
1/2
✓ Branch 0 taken 2574 times.
✗ Branch 1 not taken.
 2574 new (m_ptr) my_decimal(*dec);
6222 } else
6223 3374006 memcpy(m_ptr, from, length);
6224
6225 3376580 m_length = length;
6226 3376580 m_type = type;
6227
6228 3376580 set_used_query_id(current_thd->query_id);
6229
6230 3376576 return false;
6231 }
6232
6233 6937272 void user_var_entry::assert_locked() const {
6234 6937272 mysql_mutex_assert_owner(&m_owner->LOCK_thd_data);
6235 6937282 }
6236
6237 3376577 bool user_var_entry::store(const void *ptr, size_t length, Item_result type,
6238 const CHARSET_INFO *cs, Derivation dv,
6239 bool unsigned_arg) {
6240 3376577 assert_locked();
6241
6242
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3376576 times.
 3376579 if (store(ptr, length, type)) return true;
6243 3376576 collation.set(cs, dv);
6244 3376574 unsigned_flag = unsigned_arg;
6245 3376574 return false;
6246 }
6247
6248 3380129 void user_var_entry::lock() {
6249
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3380129 times.
 3380129 assert(m_owner != nullptr);
6250 3380129 mysql_mutex_lock(&m_owner->LOCK_thd_data);
6251 3380132 }
6252
6253 3380129 void user_var_entry::unlock() {
6254
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3380129 times.
 3380129 assert(m_owner != nullptr);
6255 3380129 mysql_mutex_unlock(&m_owner->LOCK_thd_data);
6256 3380133 }
6257
6258 3379269 bool Item_func_set_user_var::update_hash(const void *ptr, uint length,
6259 Item_result res_type,
6260 const CHARSET_INFO *cs, Derivation dv,
6261 bool unsigned_arg) {
6262 3379269 entry->lock();
6263
6264 // args[0]->null_value could be outdated
6265
2/2
✓ Branch 0 taken 27318 times.
✓ Branch 1 taken 3351953 times.
 3379272 if (args[0]->type() == Item::FIELD_ITEM)
6266 27318 null_value = ((Item_field *)args[0])->field->is_null();
6267 else
6268 3351953 null_value = args[0]->null_value;
6269
6270
2/2
✓ Branch 0 taken 2559 times.
✓ Branch 1 taken 3376712 times.
 3379271 if (ptr == nullptr) {
6271
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2559 times.
 2559 assert(length == 0);
6272 2559 null_value = true;
6273 }
6274
6275 /*
6276 If we set a variable explicitly to NULL then keep the old
6277 result type of the variable
6278 */
6279
4/4
✓ Branch 0 taken 3529 times.
✓ Branch 1 taken 3375742 times.
✓ Branch 2 taken 842 times.
✓ Branch 3 taken 2687 times.
 3379271 if (null_value && null_item) res_type = entry->type();
6280
6281
2/2
✓ Branch 0 taken 3529 times.
✓ Branch 1 taken 3375741 times.
 3379270 if (null_value)
6282 3529 entry->set_null_value(res_type);
6283
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3375739 times.
 3375741 else if (entry->store(ptr, length, res_type, cs, dv, unsigned_arg)) {
6284 ✗ entry->unlock();
6285 ✗ null_value = true;
6286 ✗ return true;
6287 }
6288 3379268 entry->unlock();
6289 3379273 return false;
6290 }
6291
6292 /** Get the value of a variable as a double. */
6293
6294 580421 double user_var_entry::val_real(bool *null_value) const {
6295
2/2
✓ Branch 0 taken 203 times.
✓ Branch 1 taken 580218 times.
 580421 if ((*null_value = (m_ptr == nullptr))) return 0.0;
6296
6297
4/6
✓ Branch 0 taken 83631 times.
✓ Branch 1 taken 490714 times.
✓ Branch 2 taken 1227 times.
✓ Branch 3 taken 4646 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 580218 switch (m_type) {
6298 83631 case REAL_RESULT:
6299 83631 return *reinterpret_cast<double *>(m_ptr);
6300 490714 case INT_RESULT:
6301
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 490709 times.
 490714 if (unsigned_flag)
6302 5 return static_cast<double>(*reinterpret_cast<ulonglong *>(m_ptr));
6303 else
6304 490709 return static_cast<double>(*reinterpret_cast<longlong *>(m_ptr));
6305 1227 case DECIMAL_RESULT: {
6306 double result;
6307
1/2
✓ Branch 0 taken 1227 times.
✗ Branch 1 not taken.
 1227 my_decimal2double(E_DEC_FATAL_ERROR, (my_decimal *)m_ptr, &result);
6308 1227 return result;
6309 }
6310 4646 case STRING_RESULT:
6311 9292 return double_from_string_with_check(collation.collation, m_ptr,
6312 4646 m_ptr + m_length);
6313 ✗ case ROW_RESULT:
6314 case INVALID_RESULT:
6315 ✗ assert(false); // Impossible
6316 break;
6317 }
6318 ✗ return 0.0; // Impossible
6319 }
6320
6321 /** Get the value of a variable as an integer. */
6322
6323 5650186 longlong user_var_entry::val_int(bool *null_value) const {
6324
2/2
✓ Branch 0 taken 1177 times.
✓ Branch 1 taken 5649009 times.
 5650186 if ((*null_value = (m_ptr == nullptr))) return 0LL;
6325
6326
4/6
✓ Branch 0 taken 112058 times.
✓ Branch 1 taken 5532799 times.
✓ Branch 2 taken 4089 times.
✓ Branch 3 taken 63 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 5649009 switch (m_type) {
6327 112058 case REAL_RESULT: {
6328 // TODO(tdidriks): Consider reporting a possible overflow warning.
6329 112058 double var_val = *(reinterpret_cast<double *>(m_ptr));
6330 longlong res;
6331
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 112058 times.
 112058 if (var_val <= LLONG_MIN) {
6332 ✗ res = LLONG_MIN;
6333
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 112058 times.
 112058 } else if (var_val >= LLONG_MAX_DOUBLE) {
6334 ✗ res = LLONG_MAX;
6335 } else
6336 112058 res = var_val;
6337
6338 112058 return res;
6339 }
6340 5532799 case INT_RESULT:
6341 5532799 return *(longlong *)m_ptr;
6342 4089 case DECIMAL_RESULT: {
6343 longlong result;
6344
1/2
✓ Branch 0 taken 4089 times.
✗ Branch 1 not taken.
 4089 my_decimal2int(E_DEC_FATAL_ERROR, (my_decimal *)m_ptr, false, &result);
6345 4089 return result;
6346 }
6347 63 case STRING_RESULT: {
6348 int error;
6349
1/2
✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
 63 return my_strtoll10(m_ptr, nullptr,
6350 63 &error); // String is null terminated
6351 }
6352 ✗ case ROW_RESULT:
6353 case INVALID_RESULT:
6354 ✗ assert(false); // Impossible
6355 break;
6356 }
6357 ✗ return 0LL; // Impossible
6358 }
6359
6360 /** Get the value of a variable as a string. */
6361
6362 1867073 String *user_var_entry::val_str(bool *null_value, String *str,
6363 uint decimals) const {
6364
2/2
✓ Branch 0 taken 4124 times.
✓ Branch 1 taken 1862949 times.
 1867073 if ((*null_value = (m_ptr == nullptr))) return (String *)nullptr;
6365
6366
4/6
✓ Branch 0 taken 62 times.
✓ Branch 1 taken 45797 times.
✓ Branch 2 taken 265 times.
✓ Branch 3 taken 1816825 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 1862949 switch (m_type) {
6367 62 case REAL_RESULT:
6368 62 str->set_real(*(double *)m_ptr, decimals, collation.collation);
6369 62 break;
6370 45797 case INT_RESULT:
6371
2/2
✓ Branch 0 taken 45572 times.
✓ Branch 1 taken 225 times.
 45797 if (!unsigned_flag)
6372 45572 str->set(*(longlong *)m_ptr, collation.collation);
6373 else
6374 225 str->set(*(ulonglong *)m_ptr, collation.collation);
6375 45797 break;
6376 265 case DECIMAL_RESULT:
6377 265 str_set_decimal(E_DEC_FATAL_ERROR, pointer_cast<my_decimal *>(m_ptr), str,
6378 265 collation.collation, decimals);
6379 265 break;
6380 1816825 case STRING_RESULT:
6381
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1816827 times.
 1816825 if (str->copy(m_ptr, m_length, collation.collation))
6382 ✗ str = nullptr; // EOM error
6383 1816827 break;
6384 ✗ case ROW_RESULT:
6385 case INVALID_RESULT:
6386 ✗ assert(false); // Impossible
6387 break;
6388 }
6389 1862951 return (str);
6390 }
6391
6392 /** Get the value of a variable as a decimal. */
6393
6394 1821 my_decimal *user_var_entry::val_decimal(bool *null_value,
6395 my_decimal *val) const {
6396
2/2
✓ Branch 0 taken 137 times.
✓ Branch 1 taken 1684 times.
 1821 if ((*null_value = (m_ptr == nullptr))) return nullptr;
6397
6398
4/6
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 43 times.
✓ Branch 2 taken 1631 times.
✓ Branch 3 taken 9 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 1684 switch (m_type) {
6399 1 case REAL_RESULT:
6400 1 double2my_decimal(E_DEC_FATAL_ERROR, *(double *)m_ptr, val);
6401 1 break;
6402 43 case INT_RESULT:
6403 43 int2my_decimal(E_DEC_FATAL_ERROR, *pointer_cast<longlong *>(m_ptr),
6404 43 unsigned_flag, val);
6405 43 break;
6406 1631 case DECIMAL_RESULT:
6407 1631 my_decimal2decimal(reinterpret_cast<my_decimal *>(m_ptr), val);
6408 1631 break;
6409 9 case STRING_RESULT:
6410 9 str2my_decimal(E_DEC_FATAL_ERROR, m_ptr, m_length, collation.collation,
6411 val);
6412 9 break;
6413 ✗ case ROW_RESULT:
6414 case INVALID_RESULT:
6415 ✗ assert(false); // Impossible
6416 break;
6417 }
6418 1684 return (val);
6419 }
6420
6421 /**
6422 This functions is invoked on SET \@variable or
6423 \@variable:= expression.
6424
6425 Evaluate (and check expression), store results.
6426
6427 @note
6428 For now it always return OK. All problem with value evaluating
6429 will be caught by thd->is_error() check in sql_set_variables().
6430
6431 @retval
6432 false OK.
6433 */
6434
6435 3199194 bool Item_func_set_user_var::check(bool use_result_field) {
6436
1/2
✓ Branch 0 taken 3199198 times.
✗ Branch 1 not taken.
 3199194 DBUG_TRACE;
6437
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 3199194 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
 3199198 if (use_result_field && !result_field) use_result_field = false;
6438
6439
5/5
✓ Branch 0 taken 92269 times.
✓ Branch 1 taken 2765805 times.
✓ Branch 2 taken 338762 times.
✓ Branch 3 taken 2360 times.
✓ Branch 4 taken 2 times.
 3199198 switch (cached_result_type) {
6440 92269 case REAL_RESULT: {
6441 92269 save_result.vreal =
6442
2/6
✗ Branch 0 not taken.
✓ Branch 1 taken 92269 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 92269 times.
✗ Branch 5 not taken.
 92269 use_result_field ? result_field->val_real() : args[0]->val_real();
6443 92269 break;
6444 }
6445 2765805 case INT_RESULT: {
6446 2765804 save_result.vint =
6447
2/6
✗ Branch 0 not taken.
✓ Branch 1 taken 2765805 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 2765804 times.
✗ Branch 5 not taken.
 2765805 use_result_field ? result_field->val_int() : args[0]->val_int();
6448
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2765804 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 2765804 unsigned_flag = use_result_field ? result_field->is_unsigned()
6449 2765804 : args[0]->unsigned_flag;
6450 2765804 break;
6451 }
6452 338762 case STRING_RESULT: {
6453
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 338758 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 338762 save_result.vstr = use_result_field ? result_field->val_str(&value)
6454
1/2
✓ Branch 0 taken 338759 times.
✗ Branch 1 not taken.
 338758 : args[0]->val_str(&value);
6455 338763 break;
6456 }
6457 2360 case DECIMAL_RESULT: {
6458 2360 save_result.vdec = use_result_field
6459
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2360 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 2360 ? result_field->val_decimal(&decimal_buff)
6460
1/2
✓ Branch 0 taken 2360 times.
✗ Branch 1 not taken.
 2360 : args[0]->val_decimal(&decimal_buff);
6461 2360 break;
6462 }
6463 2 case ROW_RESULT:
6464 default:
6465 // This case should never be chosen
6466 2 assert(0);
6467 break;
6468 }
6469 3199196 return false;
6470 3199196 }
6471
6472 /**
6473 @brief Evaluate and store item's result.
6474 This function is invoked on "SELECT ... INTO @var ...".
6475
6476 @param item An item to get value from.
6477 */
6478
6479 173375 void Item_func_set_user_var::save_item_result(Item *item) {
6480
1/2
✓ Branch 0 taken 173375 times.
✗ Branch 1 not taken.
 173375 DBUG_TRACE;
6481
6482
4/5
✓ Branch 0 taken 11708 times.
✓ Branch 1 taken 149880 times.
✓ Branch 2 taken 10678 times.
✓ Branch 3 taken 1109 times.
✗ Branch 4 not taken.
 173375 switch (cached_result_type) {
6483 11708 case REAL_RESULT:
6484
1/2
✓ Branch 0 taken 11708 times.
✗ Branch 1 not taken.
 11708 save_result.vreal = item->val_real();
6485 11708 break;
6486 149880 case INT_RESULT:
6487
1/2
✓ Branch 0 taken 149880 times.
✗ Branch 1 not taken.
 149880 save_result.vint = item->val_int();
6488 149880 unsigned_flag = item->unsigned_flag;
6489 149880 break;
6490 10678 case STRING_RESULT:
6491
1/2
✓ Branch 0 taken 10678 times.
✗ Branch 1 not taken.
 10678 save_result.vstr = item->val_str(&value);
6492 10678 break;
6493 1109 case DECIMAL_RESULT:
6494
1/2
✓ Branch 0 taken 1109 times.
✗ Branch 1 not taken.
 1109 save_result.vdec = item->val_decimal(&decimal_buff);
6495 1109 break;
6496 ✗ case ROW_RESULT:
6497 default:
6498 // Should never happen
6499 ✗ assert(0);
6500 break;
6501 }
6502 173375 }
6503
6504 /**
6505 Update user variable from value in save_result
6506
6507 @returns false if success, true when error (EOM)
6508 */
6509
6510 3372523 bool Item_func_set_user_var::update() {
6511
1/2
✓ Branch 0 taken 3372527 times.
✗ Branch 1 not taken.
 3372523 DBUG_TRACE;
6512
6513 // Ensure that a user variable object is bound for each execution.
6514
6/10
✓ Branch 0 taken 972317 times.
✓ Branch 1 taken 2400210 times.
✓ Branch 2 taken 972317 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 972317 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 972317 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 3372527 times.
 3372527 if (entry == nullptr && set_entry(current_thd, true)) return true;
6515
6516 3372527 bool res = false;
6517
6518
5/5
✓ Branch 0 taken 103976 times.
✓ Branch 1 taken 2915672 times.
✓ Branch 2 taken 349408 times.
✓ Branch 3 taken 3469 times.
✓ Branch 4 taken 2 times.
 3372527 switch (cached_result_type) {
6519 103976 case REAL_RESULT: {
6520
2/4
✓ Branch 0 taken 103976 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 103976 times.
✗ Branch 3 not taken.
 103976 res = update_hash(&save_result.vreal, sizeof(save_result.vreal),
6521 REAL_RESULT, default_charset(), DERIVATION_IMPLICIT,
6522 false);
6523 103976 break;
6524 }
6525 2915672 case INT_RESULT: {
6526
1/2
✓ Branch 0 taken 2915675 times.
✗ Branch 1 not taken.
 2915672 res = update_hash(&save_result.vint, sizeof(save_result.vint), INT_RESULT,
6527
1/2
✓ Branch 0 taken 2915672 times.
✗ Branch 1 not taken.
 2915672 default_charset(), DERIVATION_IMPLICIT, unsigned_flag);
6528 2915675 break;
6529 }
6530 349408 case STRING_RESULT: {
6531
2/2
✓ Branch 0 taken 1615 times.
✓ Branch 1 taken 347793 times.
 349408 if (!save_result.vstr) // Null value
6532
1/2
✓ Branch 0 taken 1615 times.
✗ Branch 1 not taken.
 1615 res = update_hash(nullptr, 0, STRING_RESULT, &my_charset_bin,
6533 DERIVATION_IMPLICIT, false);
6534 else
6535
1/2
✓ Branch 0 taken 347794 times.
✗ Branch 1 not taken.
 347793 res = update_hash(save_result.vstr->ptr(), save_result.vstr->length(),
6536 347793 STRING_RESULT, save_result.vstr->charset(),
6537 DERIVATION_IMPLICIT, false);
6538 349409 break;
6539 }
6540 3469 case DECIMAL_RESULT: {
6541
2/2
✓ Branch 0 taken 902 times.
✓ Branch 1 taken 2567 times.
 3469 if (!save_result.vdec) // Null value
6542
1/2
✓ Branch 0 taken 902 times.
✗ Branch 1 not taken.
 902 res = update_hash(nullptr, 0, DECIMAL_RESULT, &my_charset_bin,
6543 DERIVATION_IMPLICIT, false);
6544 else
6545
2/4
✓ Branch 0 taken 2567 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2567 times.
✗ Branch 3 not taken.
 2567 res = update_hash(save_result.vdec, sizeof(my_decimal), DECIMAL_RESULT,
6546 default_charset(), DERIVATION_IMPLICIT, false);
6547 3469 break;
6548 }
6549 2 case ROW_RESULT:
6550 default:
6551 // This case should never be chosen
6552 2 assert(0);
6553 break;
6554 }
6555 3372529 return res;
6556 3372529 }
6557
6558 169 double Item_func_set_user_var::val_real() {
6559
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 169 times.
 169 assert(fixed == 1);
6560 169 check(false);
6561 169 update(); // Store expression
6562 169 return entry->val_real(&null_value);
6563 }
6564
6565 107912 longlong Item_func_set_user_var::val_int() {
6566
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 107912 times.
 107912 assert(fixed == 1);
6567 107912 check(false);
6568 107912 update(); // Store expression
6569 107912 return entry->val_int(&null_value);
6570 }
6571
6572 32594 String *Item_func_set_user_var::val_str(String *str) {
6573
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32594 times.
 32594 assert(fixed == 1);
6574 32594 check(false);
6575 32594 update(); // Store expression
6576 32594 return entry->val_str(&null_value, str, decimals);
6577 }
6578
6579 14 my_decimal *Item_func_set_user_var::val_decimal(my_decimal *val) {
6580
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
 14 assert(fixed == 1);
6581 14 check(false);
6582 14 update(); // Store expression
6583 14 return entry->val_decimal(&null_value, val);
6584 }
6585
6586 // just the assignment, for use in "SET @a:=5" type self-prints
6587 19 void Item_func_set_user_var::print_assignment(
6588 const THD *thd, String *str, enum_query_type query_type) const {
6589 19 str->append(STRING_WITH_LEN("@"));
6590 19 str->append(name);
6591 19 str->append(STRING_WITH_LEN(":="));
6592 19 args[0]->print(thd, str, query_type);
6593 19 }
6594
6595 // parenthesize assignment for use in "EXPLAIN EXTENDED SELECT (@e:=80)+5"
6596 19 void Item_func_set_user_var::print(const THD *thd, String *str,
6597 enum_query_type query_type) const {
6598 19 str->append(STRING_WITH_LEN("("));
6599 19 print_assignment(thd, str, query_type);
6600 19 str->append(STRING_WITH_LEN(")"));
6601 19 }
6602
6603 8701 bool Item_func_set_user_var::send(Protocol *protocol, String *str_arg) {
6604
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8701 times.
 8701 if (result_field) {
6605 ✗ check(true);
6606 ✗ update();
6607 /*
6608 TODO This func have to be changed to avoid sending data as a field.
6609 */
6610 ✗ return protocol->store_field(result_field);
6611 }
6612 8701 return Item::send(protocol, str_arg);
6613 }
6614
6615 2838 void Item_func_set_user_var::make_field(Send_field *tmp_field) {
6616
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2838 times.
 2838 if (result_field) {
6617 ✗ result_field->make_send_field(tmp_field);
6618 ✗ assert(tmp_field->table_name != nullptr);
6619 ✗ if (Item::item_name.is_set())
6620 ✗ tmp_field->col_name = Item::item_name.ptr(); // Use user supplied name
6621 } else
6622 2838 Item::make_field(tmp_field);
6623 2838 }
6624
6625 /*
6626 Save the value of a user variable into a field
6627
6628 SYNOPSIS
6629 save_in_field()
6630 field target field to save the value to
6631 no_conversion flag indicating whether conversions are allowed
6632
6633 DESCRIPTION
6634 Save the function value into a field and update the user variable
6635 accordingly. If a result field is defined and the target field doesn't
6636 coincide with it then the value from the result field will be used as
6637 the new value of the user variable.
6638
6639 The reason to have this method rather than simply using the result
6640 field in the val_xxx() methods is that the value from the result field
6641 not always can be used when the result field is defined.
6642 Let's consider the following cases:
6643 1) when filling a tmp table the result field is defined but the value of it
6644 is undefined because it has to be produced yet. Thus we can't use it.
6645 2) on execution of an INSERT ... SELECT statement the save_in_field()
6646 function will be called to fill the data in the new record. If the SELECT
6647 part uses a tmp table then the result field is defined and should be
6648 used in order to get the correct result.
6649
6650 The difference between the SET_USER_VAR function and regular functions
6651 like CONCAT is that the Item_func objects for the regular functions are
6652 replaced by Item_field objects after the values of these functions have
6653 been stored in a tmp table. Yet an object of the Item_field class cannot
6654 be used to update a user variable.
6655 Due to this we have to handle the result field in a special way here and
6656 in the Item_func_set_user_var::send() function.
6657
6658 RETURN VALUES
6659 TYPE_OK Ok
6660 Everything else Error
6661 */
6662
6663 2262886 type_conversion_status Item_func_set_user_var::save_in_field(
6664 Field *field, bool no_conversions, bool can_use_result_field) {
6665 2262886 bool use_result_field =
6666
5/6
✓ Branch 0 taken 2262886 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 45342 times.
✓ Branch 3 taken 2217544 times.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 45338 times.
 2262886 (!can_use_result_field ? 0 : (result_field && result_field != field));
6667 type_conversion_status error;
6668
6669 /* Update the value of the user variable */
6670 2262886 check(use_result_field);
6671 2262886 update();
6672
6673
4/4
✓ Branch 0 taken 2212847 times.
✓ Branch 1 taken 50039 times.
✓ Branch 2 taken 50049 times.
✓ Branch 3 taken 2212837 times.
 4475733 if (result_type() == STRING_RESULT ||
6674
4/4
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 2212819 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 18 times.
 2212847 (result_type() == REAL_RESULT && field->result_type() == STRING_RESULT)) {
6675 String *result;
6676 50049 const CHARSET_INFO *cs = collation.collation;
6677 char buff[MAX_FIELD_WIDTH]; // Alloc buffer for small columns
6678 50049 str_value.set_quick(buff, sizeof(buff), cs);
6679
1/2
✓ Branch 0 taken 50049 times.
✗ Branch 1 not taken.
 50049 result = entry->val_str(&null_value, &str_value, decimals);
6680
6681
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 50047 times.
 50049 if (null_value) {
6682 2 str_value.set_quick(nullptr, 0, cs);
6683
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 return set_field_to_null_with_conversions(field, no_conversions);
6684 }
6685
6686 /* NOTE: If null_value == false, "result" must be not NULL. */
6687
6688
1/2
✓ Branch 0 taken 50047 times.
✗ Branch 1 not taken.
 50047 field->set_notnull();
6689
1/2
✓ Branch 0 taken 50047 times.
✗ Branch 1 not taken.
 50047 error = field->store(result->ptr(), result->length(), cs);
6690 50047 str_value.set_quick(nullptr, 0, cs);
6691
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 2212819 times.
 2212837 } else if (result_type() == REAL_RESULT) {
6692 18 double nr = entry->val_real(&null_value);
6693
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
 18 if (null_value) return set_field_to_null(field);
6694 18 field->set_notnull();
6695 18 error = field->store(nr);
6696
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 2212810 times.
 2212819 } else if (result_type() == DECIMAL_RESULT) {
6697 9 my_decimal decimal_value;
6698
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 my_decimal *val = entry->val_decimal(&null_value, &decimal_value);
6699
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 9 if (null_value) return set_field_to_null(field);
6700
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 field->set_notnull();
6701
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 error = field->store_decimal(val);
6702
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 } else {
6703 2212810 longlong nr = entry->val_int(&null_value);
6704
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2212810 times.
 2212810 if (null_value)
6705 ✗ return set_field_to_null_with_conversions(field, no_conversions);
6706 2212810 field->set_notnull();
6707 2212810 error = field->store(nr, unsigned_flag);
6708 }
6709 2262884 return error;
6710 }
6711
6712 1744398 String *Item_func_get_user_var::val_str(String *str) {
6713
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1744398 times.
 1744398 assert(fixed);
6714
1/2
✓ Branch 0 taken 1744400 times.
✗ Branch 1 not taken.
 1744398 DBUG_TRACE;
6715
1/2
✓ Branch 0 taken 1744400 times.
✗ Branch 1 not taken.
 1744400 THD *thd = current_thd;
6716
3/4
✓ Branch 0 taken 414932 times.
✓ Branch 1 taken 1329468 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1744401 times.
 2159333 if (var_entry == nullptr &&
6717
2/4
✓ Branch 0 taken 414933 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 414933 times.
 414932 get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry))
6718 ✗ return error_str();
6719
3/4
✓ Branch 0 taken 370 times.
✓ Branch 1 taken 1744031 times.
✓ Branch 2 taken 370 times.
✗ Branch 3 not taken.
 1744401 if (var_entry == nullptr) return error_str(); // No such variable
6720
1/2
✓ Branch 0 taken 1744030 times.
✗ Branch 1 not taken.
 1744031 String *res = var_entry->val_str(&null_value, str, decimals);
6721
7/8
✓ Branch 0 taken 1740281 times.
✓ Branch 1 taken 3749 times.
✓ Branch 2 taken 1740279 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2582 times.
✓ Branch 5 taken 1737697 times.
✓ Branch 6 taken 2582 times.
✓ Branch 7 taken 1741446 times.
 1744030 if (res && !my_charset_same(res->charset(), collation.collation)) {
6722 2582 String tmpstr;
6723 uint error;
6724
1/2
✓ Branch 0 taken 2582 times.
✗ Branch 1 not taken.
 2582 if (tmpstr.copy(res->ptr(), res->length(), res->charset(),
6725
2/4
✓ Branch 0 taken 2582 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2582 times.
 5164 collation.collation, &error) ||
6726
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2582 times.
 2582 error > 0) {
6727 char tmp[32];
6728 ✗ convert_to_printable(tmp, sizeof(tmp), res->ptr(), res->length(),
6729 res->charset(), 6);
6730 ✗ my_error(ER_INVALID_CHARACTER_STRING, MYF(0), collation.collation->csname,
6731 tmp);
6732 ✗ return error_str();
6733 }
6734
2/6
✓ Branch 0 taken 2582 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2582 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 2582 if (str->copy(tmpstr)) return error_str();
6735 2582 return str;
6736 2582 }
6737 1741446 return res;
6738 1744398 }
6739
6740 580245 double Item_func_get_user_var::val_real() {
6741
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 580245 times.
 580245 assert(fixed);
6742 THD *thd;
6743
4/6
✓ Branch 0 taken 8398 times.
✓ Branch 1 taken 571847 times.
✓ Branch 2 taken 8398 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 580245 times.
 588643 if (var_entry == nullptr && (thd = current_thd) &&
6744
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8398 times.
 8398 get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry))
6745 ✗ return 0.0;
6746
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 580234 times.
 580245 if (var_entry == nullptr) return 0.0; // No such variable
6747 580234 return (var_entry->val_real(&null_value));
6748 }
6749
6750 1800 my_decimal *Item_func_get_user_var::val_decimal(my_decimal *dec) {
6751
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1800 times.
 1800 assert(fixed);
6752 THD *thd;
6753
4/6
✓ Branch 0 taken 1780 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 1780 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1800 times.
 3580 if (var_entry == nullptr && (thd = current_thd) &&
6754
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1780 times.
 1780 get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry))
6755 ✗ return nullptr;
6756
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1798 times.
 1800 if (var_entry == nullptr) return nullptr;
6757 1798 return var_entry->val_decimal(&null_value, dec);
6758 }
6759
6760 3323207 longlong Item_func_get_user_var::val_int() {
6761
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3323207 times.
 3323207 assert(fixed);
6762 THD *thd;
6763
5/6
✓ Branch 0 taken 823105 times.
✓ Branch 1 taken 2500102 times.
✓ Branch 2 taken 823100 times.
✓ Branch 3 taken 4 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 3323208 times.
 4146309 if (var_entry == nullptr && (thd = current_thd) &&
6764
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 823102 times.
 823100 get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry))
6765 ✗ return 0LL;
6766
2/2
✓ Branch 0 taken 1359 times.
✓ Branch 1 taken 3321849 times.
 3323208 if (var_entry == nullptr) return 0LL; // No such variable
6767 /*
6768 See bug#27969934 NO WARNING WHEN CAST OF USER VARIABLE
6769 TO NUMBER GOES WRONG.
6770 */
6771 3321849 return var_entry->val_int(&null_value);
6772 }
6773
6774 81187 const CHARSET_INFO *Item_func_get_user_var::charset_for_protocol() {
6775
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 81187 times.
 81187 assert(fixed);
6776 THD *thd;
6777 /*
6778 If the query reads the value of the variable's charset it depends on this
6779 variable, so the user var may need to be stored in the binlog: so we call
6780 get_var_with_binlog.
6781 */
6782
4/6
✓ Branch 0 taken 40841 times.
✓ Branch 1 taken 40346 times.
✓ Branch 2 taken 40841 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 81187 times.
 122028 if (var_entry == nullptr && (thd = current_thd) &&
6783
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40841 times.
 40841 get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry))
6784 ✗ return &my_charset_bin;
6785
2/2
✓ Branch 0 taken 292 times.
✓ Branch 1 taken 80895 times.
 81187 if (var_entry == nullptr) return &my_charset_bin; // No such variable
6786 // @todo WL#6570 Should we return collation of Item node or variable entry?
6787
2/2
✓ Branch 0 taken 54081 times.
✓ Branch 1 taken 26814 times.
 80895 return result_type() == STRING_RESULT ? collation.collation : &my_charset_bin;
6788 }
6789
6790 /**
6791 Get variable by name and, if necessary, put the record of variable
6792 use into the binary log.
6793
6794 When a user variable is invoked from an update query (INSERT, UPDATE etc),
6795 stores this variable and its value in thd->user_var_events, so that it can be
6796 written to the binlog (will be written just before the query is written, see
6797 log.cc).
6798
6799 @param thd Current session.
6800 @param sql_command The command the variable participates in.
6801 @param name Variable name
6802 @param[out] out_entry variable structure or NULL. The pointer is set
6803 regardless of whether function succeeded or not.
6804
6805 @retval
6806 0 OK
6807 @retval
6808 1 Failed to put appropriate record into binary log
6809
6810 */
6811
6812 1289054 static int get_var_with_binlog(THD *thd, enum_sql_command sql_command,
6813 const Name_string &name,
6814 user_var_entry **out_entry) {
6815 Binlog_user_var_event *user_var_event;
6816 user_var_entry *var_entry;
6817
6818 /* Protects thd->user_vars. */
6819
1/2
✓ Branch 0 taken 1289053 times.
✗ Branch 1 not taken.
 1289054 mysql_mutex_lock(&thd->LOCK_thd_data);
6820
1/2
✓ Branch 0 taken 1289054 times.
✗ Branch 1 not taken.
 1289053 var_entry = get_variable(thd, name, nullptr);
6821
1/2
✓ Branch 0 taken 1289058 times.
✗ Branch 1 not taken.
 1289054 mysql_mutex_unlock(&thd->LOCK_thd_data);
6822
6823 1289058 *out_entry = var_entry;
6824
6825 /*
6826 In cases when this function is called for a sub-statement, we can't
6827 rely on OPTION_BIN_LOG flag in THD::variables.option_bits bitmap
6828 to determine whether binary logging is turned on, as this bit can be
6829 cleared before executing sub-statement. So instead we have to look
6830 at THD::variables::sql_log_bin member.
6831 */
6832
4/4
✓ Branch 0 taken 1229824 times.
✓ Branch 1 taken 59234 times.
✓ Branch 2 taken 1160045 times.
✓ Branch 3 taken 69779 times.
 1289058 bool log_on = mysql_bin_log.is_open() && thd->variables.sql_log_bin;
6833
6834 /*
6835 Any reference to user-defined variable which is done from stored
6836 function or trigger affects their execution and the execution of the
6837 calling statement. We must log all such variables even if they are
6838 not involved in table-updating statements.
6839 */
6840
9/10
✓ Branch 0 taken 1160045 times.
✓ Branch 1 taken 129013 times.
✓ Branch 2 taken 1160044 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 970803 times.
✓ Branch 5 taken 189241 times.
✓ Branch 6 taken 963846 times.
✓ Branch 7 taken 6957 times.
✓ Branch 8 taken 1092859 times.
✓ Branch 9 taken 196198 times.
 1289058 if (!(log_on && (is_update_query(sql_command) || thd->in_sub_stmt))) return 0;
6841
6842
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 196148 times.
 196198 if (var_entry == nullptr) {
6843 /*
6844 If the variable does not exist, it's NULL, but we want to create it so
6845 that it gets into the binlog (if it didn't, the slave could be
6846 influenced by a variable of the same name previously set by another
6847 thread).
6848 We create it like if it had been explicitly set with SET before.
6849 The 'new' mimics what sql_yacc.yy does when 'SET @a=10;'.
6850 sql_set_variables() is what is called from 'case SQLCOM_SET_OPTION'
6851 in dispatch_command()). Instead of building a one-element list to pass to
6852 sql_set_variables(), we could instead manually call check() and update();
6853 this would save memory and time; but calling sql_set_variables() makes
6854 one unique place to maintain (sql_set_variables()).
6855
6856 Manipulation with lex is necessary since free_underlaid_joins
6857 is going to release memory belonging to the main query.
6858 */
6859
6860 50 List<set_var_base> tmp_var_list;
6861
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 LEX *sav_lex = thd->lex, lex_tmp;
6862 50 thd->lex = &lex_tmp;
6863
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 lex_start(thd);
6864
2/4
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50 times.
✗ Branch 3 not taken.
 100 tmp_var_list.push_back(new (thd->mem_root) set_var_user(
6865
3/6
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 50 times.
✗ Branch 5 not taken.
 150 new Item_func_set_user_var(name, new Item_null())));
6866 /* Create the variable */
6867
2/4
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 50 times.
 50 if (sql_set_variables(thd, &tmp_var_list, false)) {
6868 ✗ thd->lex = sav_lex;
6869 ✗ return 1;
6870 }
6871 50 thd->lex = sav_lex;
6872
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 mysql_mutex_lock(&thd->LOCK_thd_data);
6873
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 var_entry = get_variable(thd, name, nullptr);
6874
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 mysql_mutex_unlock(&thd->LOCK_thd_data);
6875
6876 50 *out_entry = var_entry;
6877
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 if (var_entry == nullptr) return 1;
6878
5/6
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 169204 times.
✓ Branch 3 taken 26944 times.
✓ Branch 4 taken 26994 times.
✓ Branch 5 taken 169154 times.
 365402 } else if (var_entry->used_query_id() == thd->query_id ||
6879
3/4
✓ Branch 0 taken 169204 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50 times.
✓ Branch 3 taken 169154 times.
 169204 mysql_bin_log.is_query_in_union(thd, var_entry->used_query_id())) {
6880 /*
6881 If this variable was already stored in user_var_events by this query
6882 (because it's used in more than one place in the query), don't store
6883 it.
6884 */
6885 26994 return 0;
6886 }
6887
6888 /*
6889 First we need to store value of var_entry, when the next situation
6890 appears:
6891 > set @a:=1;
6892 > insert into t1 values (@a), (@a:=@a+1), (@a:=@a+1);
6893 We have to write to binlog value @a= 1.
6894
6895 We allocate the user_var_event on user_var_events_alloc pool, not on
6896 the this-statement-execution pool because in SPs user_var_event objects
6897 may need to be valid after current [SP] statement execution pool is
6898 destroyed.
6899 */
6900 169204 size_t size = ALIGN_SIZE(sizeof(Binlog_user_var_event)) + var_entry->length();
6901 169204 if (!(user_var_event =
6902
2/4
✓ Branch 0 taken 169204 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 169204 times.
 169204 (Binlog_user_var_event *)thd->user_var_events_alloc->Alloc(size)))
6903 ✗ return 1;
6904
6905 169204 user_var_event->value =
6906 169204 (char *)user_var_event + ALIGN_SIZE(sizeof(Binlog_user_var_event));
6907 169204 user_var_event->user_var_event = var_entry;
6908 169204 user_var_event->type = var_entry->type();
6909 169204 user_var_event->charset_number = var_entry->collation.collation->number;
6910 169204 user_var_event->unsigned_flag = var_entry->unsigned_flag;
6911
2/2
✓ Branch 0 taken 2746 times.
✓ Branch 1 taken 166458 times.
 169204 if (!var_entry->ptr()) {
6912 /* NULL value*/
6913 2746 user_var_event->length = 0;
6914 2746 user_var_event->value = nullptr;
6915 } else {
6916 // Avoid memcpy of a my_decimal object, use copy CTOR instead.
6917 166458 user_var_event->length = var_entry->length();
6918
2/2
✓ Branch 0 taken 59 times.
✓ Branch 1 taken 166399 times.
 166458 if (user_var_event->type == DECIMAL_RESULT) {
6919
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
 59 assert(var_entry->length() == sizeof(my_decimal));
6920 const my_decimal *dec = static_cast<const my_decimal *>(
6921 59 static_cast<const void *>(var_entry->ptr()));
6922 59 dec->sanity_check();
6923
1/2
✓ Branch 0 taken 59 times.
✗ Branch 1 not taken.
 59 new (user_var_event->value) my_decimal(*dec);
6924 } else
6925 166399 memcpy(user_var_event->value, var_entry->ptr(), var_entry->length());
6926 }
6927 // Mark that this variable has been used by this query
6928 169204 var_entry->set_used_query_id(thd->query_id);
6929
2/4
✓ Branch 0 taken 169204 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 169204 times.
 169204 if (thd->user_var_events.push_back(user_var_event)) return 1;
6930
6931 169204 return 0;
6932 }
6933
6934 614819 bool Item_func_get_user_var::resolve_type(THD *thd) {
6935 614819 set_nullable(true);
6936
6937 /*
6938 @todo WL#6570 change has effects:
6939 - bad: in packet.test (see comment there), ps_<n><engine>.test
6940 (e.g. ps_5merge.test) (see comment in include/ps_conv.inc),
6941 ps_w_max_indexes_64
6942 - good: type_temporal_fractional.test (see comment in that file)
6943 - fixes failure of: sysschema.pr_statement_performance_analyzer and
6944 sysschema.format_statement.
6945 Don't forget to grep for "WL#6570" in the whole tree, including mtr
6946 tests.
6947 */
6948 614819 used_tables_cache =
6949
2/2
✓ Branch 0 taken 2470 times.
✓ Branch 1 taken 612349 times.
 614819 thd->lex->locate_var_assignment(name) ? RAND_TABLE_BIT : INNER_TABLE_BIT;
6950
6951 614819 mysql_mutex_lock(&thd->LOCK_thd_data);
6952 614819 var_entry = get_variable(thd, name, nullptr);
6953 614819 mysql_mutex_unlock(&thd->LOCK_thd_data);
6954
6955
2/2
✓ Branch 0 taken 600552 times.
✓ Branch 1 taken 14267 times.
 614819 if (var_entry != nullptr) {
6956 // Variable exists - assign type information from the entry.
6957 600552 m_cached_result_type = var_entry->type();
6958
6959
4/5
✓ Branch 0 taken 4001 times.
✓ Branch 1 taken 270466 times.
✓ Branch 2 taken 319701 times.
✓ Branch 3 taken 6384 times.
✗ Branch 4 not taken.
 600552 switch (m_cached_result_type) {
6960 4001 case REAL_RESULT:
6961 4001 set_data_type_double();
6962 4001 break;
6963 270466 case INT_RESULT:
6964 270466 set_data_type_longlong();
6965 270466 unsigned_flag = var_entry->unsigned_flag;
6966 270466 break;
6967 319701 case STRING_RESULT:
6968 319701 set_data_type_string(uint32(MAX_BLOB_WIDTH - 1), var_entry->collation);
6969 319701 break;
6970 6384 case DECIMAL_RESULT:
6971 6384 set_data_type_decimal(DECIMAL_MAX_PRECISION, DECIMAL_MAX_SCALE);
6972 6384 break;
6973 ✗ case ROW_RESULT: // Keep compiler happy
6974 default:
6975 ✗ assert(0);
6976 break;
6977 }
6978
6979 // Override collation for all data types
6980 600552 collation.set(var_entry->collation);
6981 } else {
6982 // Unknown user variable, assign expected type from context.
6983 14267 null_value = true;
6984 }
6985 614819 collation.set(DERIVATION_IMPLICIT);
6986
6987 // Refresh the variable entry during execution with proper binlogging.
6988 614819 var_entry = nullptr;
6989
6990 614819 return false;
6991 }
6992
6993 14264 bool Item_func_get_user_var::propagate_type(THD *,
6994 const Type_properties &type) {
6995 /*
6996 If the type is temporal: user variables don't support that type; so, we
6997 use a VARCHAR instead. Same for JSON and GEOMETRY.
6998 BIT and YEAR types are represented with LONGLONG.
6999 */
7000
10/13
✓ Branch 0 taken 13787 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 12 times.
✓ Branch 5 taken 430 times.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 2 times.
✓ Branch 8 taken 16 times.
✓ Branch 9 taken 4 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 7 times.
✗ Branch 12 not taken.
 14264 switch (type.m_type) {
7001 13787 case MYSQL_TYPE_TINY:
7002 case MYSQL_TYPE_SHORT:
7003 case MYSQL_TYPE_INT24:
7004 case MYSQL_TYPE_LONG:
7005 case MYSQL_TYPE_LONGLONG:
7006 13787 set_data_type_longlong();
7007 13787 unsigned_flag = type.m_unsigned_flag;
7008 13787 break;
7009 1 case MYSQL_TYPE_BIT:
7010 1 set_data_type_longlong();
7011 1 unsigned_flag = true;
7012 1 break;
7013 ✗ case MYSQL_TYPE_YEAR:
7014 ✗ set_data_type_longlong();
7015 ✗ break;
7016 4 case MYSQL_TYPE_NEWDECIMAL:
7017 case MYSQL_TYPE_DECIMAL:
7018 4 set_data_type_decimal(DECIMAL_MAX_PRECISION, DECIMAL_MAX_SCALE);
7019 4 break;
7020 12 case MYSQL_TYPE_FLOAT:
7021 case MYSQL_TYPE_DOUBLE:
7022 12 set_data_type_double();
7023 12 break;
7024 430 case MYSQL_TYPE_VARCHAR:
7025 case MYSQL_TYPE_VAR_STRING:
7026 case MYSQL_TYPE_STRING:
7027 case MYSQL_TYPE_ENUM:
7028 case MYSQL_TYPE_SET:
7029 case MYSQL_TYPE_NULL:
7030 // Parameter type is VARCHAR of largest possible size
7031 430 set_data_type_string(65535U / type.m_collation.collation->mbmaxlen,
7032 430 type.m_collation);
7033 430 break;
7034 1 case MYSQL_TYPE_GEOMETRY:
7035 1 set_data_type_string(MAX_BLOB_WIDTH, type.m_collation);
7036 1 break;
7037 2 case MYSQL_TYPE_JSON:
7038 2 set_data_type_string(MAX_BLOB_WIDTH, type.m_collation);
7039 2 break;
7040 16 case MYSQL_TYPE_TINY_BLOB:
7041 case MYSQL_TYPE_MEDIUM_BLOB:
7042 case MYSQL_TYPE_LONG_BLOB:
7043 case MYSQL_TYPE_BLOB:
7044 // Parameter type is BLOB of largest possible size
7045 16 set_data_type_string(MAX_BLOB_WIDTH, type.m_collation);
7046 16 break;
7047 4 case MYSQL_TYPE_DATETIME:
7048 case MYSQL_TYPE_DATETIME2:
7049 case MYSQL_TYPE_TIMESTAMP:
7050 case MYSQL_TYPE_TIMESTAMP2:
7051 4 set_data_type_string(26, type.m_collation);
7052 4 break;
7053 ✗ case MYSQL_TYPE_DATE:
7054 case MYSQL_TYPE_NEWDATE:
7055 ✗ set_data_type_string(10, type.m_collation);
7056 ✗ break;
7057 7 case MYSQL_TYPE_TIME:
7058 case MYSQL_TYPE_TIME2:
7059 7 set_data_type_string(15, type.m_collation);
7060 7 break;
7061 ✗ default:
7062 ✗ assert(false);
7063 }
7064 // User variables have implicit derivation
7065 14264 collation.set(DERIVATION_IMPLICIT);
7066
7067 // @todo - when result_type is refactored, this may not be necessary
7068 14264 m_cached_result_type = type_to_result(data_type());
7069
7070 14264 return false;
7071 }
7072
7073 1322817 void Item_func_get_user_var::cleanup() {
7074 1322817 Item_func::cleanup();
7075 /*
7076 Ensure that a valid user variable object is rebound on next execution. See
7077 comment in Item_func_set_user_var::cleanup().
7078 */
7079 1322825 var_entry = nullptr;
7080 1322825 }
7081
7082 3030246 enum Item_result Item_func_get_user_var::result_type() const {
7083 3030246 return m_cached_result_type;
7084 }
7085
7086 561 void Item_func_get_user_var::print(const THD *thd, String *str,
7087 enum_query_type) const {
7088 561 str->append(STRING_WITH_LEN("(@"));
7089 561 append_identifier(thd, str, name.ptr(), name.length());
7090 561 str->append(')');
7091 561 }
7092
7093 14561 bool Item_func_get_user_var::eq(const Item *item, bool) const {
7094 /* Assume we don't have rtti */
7095
2/2
✓ Branch 0 taken 7210 times.
✓ Branch 1 taken 7351 times.
 14561 if (this == item) return true; // Same item is same.
7096 /* Check if other type is also a get_user_var() object */
7097
4/4
✓ Branch 0 taken 1109 times.
✓ Branch 1 taken 6242 times.
✓ Branch 2 taken 7153 times.
✓ Branch 3 taken 198 times.
 8460 if (item->type() != FUNC_ITEM ||
7098
2/2
✓ Branch 0 taken 911 times.
✓ Branch 1 taken 198 times.
 1109 down_cast<const Item_func *>(item)->functype() != functype())
7099 7153 return false;
7100 const Item_func_get_user_var *other =
7101 198 down_cast<const Item_func_get_user_var *>(item);
7102 198 return name.eq_bin(other->name);
7103 }
7104
7105 14333 bool Item_func_get_user_var::set_value(THD *thd, sp_rcontext * /*ctx*/,
7106 Item **it) {
7107
2/4
✓ Branch 0 taken 14333 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14333 times.
✗ Branch 3 not taken.
 14333 Item_func_set_user_var *suv = new Item_func_set_user_var(name, *it);
7108 /*
7109 Item_func_set_user_var is not fixed after construction, call
7110 fix_fields().
7111 */
7112
3/6
✓ Branch 0 taken 14333 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14333 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14333 times.
✗ Branch 5 not taken.
 28666 return (!suv || suv->fix_fields(thd, it) || suv->check(false) ||
7113
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14333 times.
 28666 suv->update());
7114 }
7115
7116 59 bool Item_user_var_as_out_param::fix_fields(THD *thd, Item **ref) {
7117
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
 59 assert(fixed == 0);
7118
7119
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
 59 assert(thd->lex->sql_command == SQLCOM_LOAD);
7120 auto exchange_cs =
7121 59 down_cast<Sql_cmd_load_table *>(thd->lex->m_sql_cmd)->m_exchange.cs;
7122 /*
7123 Let us set the same collation which is used for loading
7124 of fields in LOAD DATA INFILE.
7125 (Since Item_user_var_as_out_param is used only there).
7126 */
7127 59 const CHARSET_INFO *cs =
7128
2/2
✓ Branch 0 taken 57 times.
✓ Branch 1 taken 2 times.
 59 exchange_cs ? exchange_cs : thd->variables.collation_database;
7129
7130
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
 59 if (Item::fix_fields(thd, ref)) return true;
7131
7132 /* Protects thd->user_vars. */
7133 59 mysql_mutex_lock(&thd->LOCK_thd_data);
7134 59 entry = get_variable(thd, name, cs);
7135
1/2
✓ Branch 0 taken 59 times.
✗ Branch 1 not taken.
 59 if (entry != nullptr) entry->set_type(STRING_RESULT);
7136 59 mysql_mutex_unlock(&thd->LOCK_thd_data);
7137
7138 59 return entry == nullptr;
7139 }
7140
7141 24 void Item_user_var_as_out_param::set_null_value(const CHARSET_INFO *) {
7142 24 entry->lock();
7143 24 entry->set_null_value(STRING_RESULT);
7144 24 entry->unlock();
7145 24 }
7146
7147 836 void Item_user_var_as_out_param::set_value(const char *str, size_t length,
7148 const CHARSET_INFO *cs) {
7149 836 entry->lock();
7150 836 entry->store(str, length, STRING_RESULT, cs, DERIVATION_IMPLICIT,
7151 false /* unsigned_arg */);
7152 836 entry->unlock();
7153 836 }
7154
7155 ✗ double Item_user_var_as_out_param::val_real() {
7156 ✗ assert(0);
7157 return 0.0;
7158 }
7159
7160 ✗ longlong Item_user_var_as_out_param::val_int() {
7161 ✗ assert(0);
7162 return 0;
7163 }
7164
7165 ✗ String *Item_user_var_as_out_param::val_str(String *) {
7166 ✗ assert(0);
7167 return nullptr;
7168 }
7169
7170 ✗ my_decimal *Item_user_var_as_out_param::val_decimal(my_decimal *) {
7171 ✗ assert(0);
7172 return nullptr;
7173 }
7174
7175 12 void Item_user_var_as_out_param::print(const THD *thd, String *str,
7176 enum_query_type) const {
7177 12 str->append('@');
7178 12 append_identifier(thd, str, name.ptr(), name.length());
7179 12 }
7180
7181 677100 Item_func_get_system_var::Item_func_get_system_var(
7182 677100 const System_variable_tracker &var_tracker, enum_var_type scope)
7183
1/2
✓ Branch 0 taken 677099 times.
✗ Branch 1 not taken.
 677100 : var_scope{scope}, cache_present{0}, var_tracker{var_tracker} {
7184
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 677099 times.
 677099 assert(scope != OPT_DEFAULT);
7185 677099 }
7186
7187 585907 bool Item_func_get_system_var::resolve_type(THD *) {
7188 585907 set_nullable(true);
7189
7190
5/6
✓ Branch 0 taken 183065 times.
✓ Branch 1 taken 801 times.
✓ Branch 2 taken 291323 times.
✓ Branch 3 taken 110388 times.
✓ Branch 4 taken 330 times.
✗ Branch 5 not taken.
 585907 switch (var_tracker.cached_show_type()) {
7191 183065 case SHOW_LONG:
7192 case SHOW_INT:
7193 case SHOW_HA_ROWS:
7194 case SHOW_LONGLONG:
7195 183065 set_data_type_longlong();
7196 183065 unsigned_flag = true;
7197 183065 break;
7198 801 case SHOW_SIGNED_INT:
7199 case SHOW_SIGNED_LONG:
7200 case SHOW_SIGNED_LONGLONG:
7201 801 set_data_type_longlong();
7202 801 unsigned_flag = false;
7203 801 break;
7204 291323 case SHOW_CHAR:
7205 case SHOW_CHAR_PTR:
7206 case SHOW_LEX_STRING:
7207 291323 collation.set(system_charset_info, DERIVATION_SYSCONST);
7208 291323 set_data_type_string(65535U / collation.collation->mbmaxlen);
7209 291323 break;
7210 110388 case SHOW_BOOL:
7211 case SHOW_MY_BOOL:
7212 110388 set_data_type_longlong();
7213 110388 max_length = 1;
7214 110388 break;
7215 330 case SHOW_DOUBLE:
7216 330 set_data_type_double();
7217 // Override decimals and length calculation done above.
7218 330 decimals = 6;
7219 330 max_length = float_length(decimals);
7220 330 break;
7221 ✗ default:
7222 ✗ my_error(ER_VAR_CANT_BE_READ, MYF(0), var_tracker.get_var_name());
7223 ✗ return true;
7224 }
7225 585907 return false;
7226 }
7227
7228 36 void Item_func_get_system_var::print(const THD *, String *str,
7229 enum_query_type) const {
7230 36 str->append(item_name);
7231 36 }
7232
7233 661490 Audit_global_variable_get_event::Audit_global_variable_get_event(
7234 661490 THD *thd, Item_func_get_system_var *item, uchar cache_type)
7235 661490 : m_thd(thd), m_item(item), m_val_type(cache_type) {
7236 // Variable is of GLOBAL scope.
7237 661490 bool is_global_var = m_item->var_scope == OPT_GLOBAL;
7238
7239 // Event is already audited for the same query.
7240 661490 bool event_is_audited =
7241
3/4
✓ Branch 0 taken 774 times.
✓ Branch 1 taken 660716 times.
✓ Branch 2 taken 774 times.
✗ Branch 3 not taken.
 661490 m_item->cache_present != 0 && m_item->used_query_id == m_thd->query_id;
7242
7243
4/4
✓ Branch 0 taken 540356 times.
✓ Branch 1 taken 121134 times.
✓ Branch 2 taken 539655 times.
✓ Branch 3 taken 701 times.
 661490 m_audit_event = (is_global_var && !event_is_audited);
7244 661490 }
7245
7246 661502 Audit_global_variable_get_event::~Audit_global_variable_get_event() {
7247 /*
7248 While converting value to string, integer or real type, if the value is
7249 cached for the types other then m_val_type for intermediate type
7250 conversions then event is already notified.
7251 */
7252 661502 bool event_already_notified = (m_item->cache_present & (~m_val_type));
7253
7254
4/4
✓ Branch 0 taken 539657 times.
✓ Branch 1 taken 121845 times.
✓ Branch 2 taken 506966 times.
✓ Branch 3 taken 32691 times.
 661502 if (m_audit_event && !event_already_notified) {
7255 506966 String str;
7256 506966 String *outStr = nullptr;
7257
7258
4/6
✓ Branch 0 taken 374 times.
✓ Branch 1 taken 506592 times.
✓ Branch 2 taken 374 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 506966 times.
✗ Branch 5 not taken.
 506966 if (!m_item->cached_null_value || !m_thd->is_error()) {
7259 506966 outStr = &str;
7260
7261
2/4
✓ Branch 0 taken 506966 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 506966 times.
✗ Branch 3 not taken.
 506966 assert(m_item->cache_present != 0 &&
7262 m_item->used_query_id == m_thd->query_id);
7263
7264
2/2
✓ Branch 0 taken 301385 times.
✓ Branch 1 taken 205581 times.
 506966 if (m_item->cache_present & GET_SYS_VAR_CACHE_STRING)
7265 301385 outStr = &m_item->cached_strval;
7266
2/2
✓ Branch 0 taken 205429 times.
✓ Branch 1 taken 152 times.
 205581 else if (m_item->cache_present & GET_SYS_VAR_CACHE_LONG)
7267 205429 str.set(m_item->cached_llval, m_item->collation.collation);
7268
1/2
✓ Branch 0 taken 152 times.
✗ Branch 1 not taken.
 152 else if (m_item->cache_present & GET_SYS_VAR_CACHE_DOUBLE)
7269 152 str.set_real(m_item->cached_dval, m_item->decimals,
7270 152 m_item->collation.collation);
7271 }
7272
7273
2/4
✓ Branch 0 taken 506966 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 506966 times.
✗ Branch 3 not taken.
 1520898 mysql_audit_notify(m_thd, AUDIT_EVENT(MYSQL_AUDIT_GLOBAL_VARIABLE_GET),
7274 506966 m_item->var_tracker.get_var_name(),
7275 506966 outStr ? outStr->ptr() : nullptr,
7276 506966 outStr ? outStr->length() : 0);
7277 506966 }
7278 661502 }
7279
7280 template <typename T>
7281 593950 longlong Item_func_get_system_var::get_sys_var_safe(THD *thd, sys_var *var) {
7282 593950 T value = {};
7283 {
7284 593950 MUTEX_LOCK(lock, &LOCK_global_system_variables);
7285 593950 std::string_view keycache_name = var_tracker.get_keycache_name();
7286 593950 value =
7287
1/2
✓ Branch 0 taken 296975 times.
✗ Branch 1 not taken.
 593950 *pointer_cast<const T *>(var->value_ptr(thd, var_scope, keycache_name));
7288 593950 }
7289 593950 cache_present |= GET_SYS_VAR_CACHE_LONG;
7290 593950 used_query_id = thd->query_id;
7291
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 296975 times.
 593950 cached_llval = null_value ? 0LL : static_cast<longlong>(value);
7292 593950 cached_null_value = null_value;
7293 593950 return cached_llval;
7294 }
7295
7296 297476 longlong Item_func_get_system_var::val_int() {
7297
1/2
✓ Branch 0 taken 297477 times.
✗ Branch 1 not taken.
 297476 THD *thd = current_thd;
7298 Audit_global_variable_get_event audit_sys_var(thd, this,
7299
1/2
✓ Branch 0 taken 297478 times.
✗ Branch 1 not taken.
 297477 GET_SYS_VAR_CACHE_LONG);
7300
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 297478 times.
 297478 assert(fixed);
7301
7302
3/4
✓ Branch 0 taken 501 times.
✓ Branch 1 taken 296977 times.
✓ Branch 2 taken 501 times.
✗ Branch 3 not taken.
 297478 if (cache_present && thd->query_id == used_query_id) {
7303
1/2
✓ Branch 0 taken 501 times.
✗ Branch 1 not taken.
 501 if (cache_present & GET_SYS_VAR_CACHE_LONG) {
7304 501 null_value = cached_null_value;
7305 501 return cached_llval;
7306 ✗ } else if (cache_present & GET_SYS_VAR_CACHE_DOUBLE) {
7307 ✗ null_value = cached_null_value;
7308 ✗ cached_llval = (longlong)cached_dval;
7309 ✗ cache_present |= GET_SYS_VAR_CACHE_LONG;
7310 ✗ return cached_llval;
7311 ✗ } else if (cache_present & GET_SYS_VAR_CACHE_STRING) {
7312 ✗ null_value = cached_null_value;
7313 ✗ if (!null_value)
7314 ✗ cached_llval = longlong_from_string_with_check(
7315 ✗ cached_strval.charset(), cached_strval.c_ptr(),
7316 ✗ cached_strval.c_ptr() + cached_strval.length(), unsigned_flag);
7317 else
7318 ✗ cached_llval = 0;
7319 ✗ cache_present |= GET_SYS_VAR_CACHE_LONG;
7320 ✗ return cached_llval;
7321 }
7322 }
7323
7324 296977 auto f = [this, thd](const System_variable_tracker &,
7325 296982 sys_var *var) -> longlong {
7326
9/12
✓ Branch 0 taken 20010 times.
✓ Branch 1 taken 156546 times.
✓ Branch 2 taken 8850 times.
✓ Branch 3 taken 347 times.
✓ Branch 4 taken 271 times.
✓ Branch 5 taken 195 times.
✓ Branch 6 taken 64 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 110692 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 2 times.
✗ Branch 11 not taken.
 296977 switch (var->show_type()) {
7327 20010 case SHOW_INT:
7328 20010 return get_sys_var_safe<uint>(thd, var);
7329 156546 case SHOW_LONG:
7330 156546 return get_sys_var_safe<ulong>(thd, var);
7331 8850 case SHOW_LONGLONG:
7332 8850 return get_sys_var_safe<ulonglong>(thd, var);
7333 347 case SHOW_SIGNED_INT:
7334 347 return get_sys_var_safe<int>(thd, var);
7335 271 case SHOW_SIGNED_LONG:
7336 271 return get_sys_var_safe<long>(thd, var);
7337 195 case SHOW_SIGNED_LONGLONG:
7338 195 return get_sys_var_safe<longlong>(thd, var);
7339 64 case SHOW_HA_ROWS:
7340 64 return get_sys_var_safe<ha_rows>(thd, var);
7341 ✗ case SHOW_BOOL:
7342 ✗ return get_sys_var_safe<bool>(thd, var);
7343 110692 case SHOW_MY_BOOL:
7344 110692 return get_sys_var_safe<bool>(thd, var);
7345 ✗ case SHOW_DOUBLE: {
7346 ✗ double dval = val_real();
7347
7348 ✗ used_query_id = thd->query_id;
7349 ✗ cached_llval = (longlong)dval;
7350 ✗ cache_present |= GET_SYS_VAR_CACHE_LONG;
7351 ✗ return cached_llval;
7352 }
7353 2 case SHOW_CHAR:
7354 case SHOW_CHAR_PTR:
7355 case SHOW_LEX_STRING: {
7356 2 String *str_val = val_str(nullptr);
7357 // Treat empty strings as NULL, like val_real() does.
7358
5/6
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 1 times.
 2 if (str_val && str_val->length())
7359 1 cached_llval = longlong_from_string_with_check(
7360 1 system_charset_info, str_val->c_ptr(),
7361 1 str_val->c_ptr() + str_val->length(), unsigned_flag);
7362 else {
7363 1 null_value = true;
7364 1 cached_llval = 0;
7365 }
7366
7367 2 cache_present |= GET_SYS_VAR_CACHE_LONG;
7368 2 return cached_llval;
7369 }
7370
7371 ✗ default:
7372 ✗ my_error(ER_VAR_CANT_BE_READ, MYF(0), var->name.str);
7373 ✗ return 0; // keep the compiler happy
7374 }
7375 296977 };
7376
1/2
✓ Branch 0 taken 296977 times.
✗ Branch 1 not taken.
 296977 return var_tracker.access_system_variable<longlong>(thd, f).value_or(0);
7377 297478 }
7378
7379 360681 String *Item_func_get_system_var::val_str(String *str) {
7380
4/6
✓ Branch 0 taken 359870 times.
✓ Branch 1 taken 817 times.
✓ Branch 2 taken 359871 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 359872 times.
✗ Branch 5 not taken.
 360681 DEBUG_SYNC(current_thd, "after_error_checking");
7381
1/2
✓ Branch 0 taken 360690 times.
✗ Branch 1 not taken.
 360689 THD *thd = current_thd;
7382 Audit_global_variable_get_event audit_sys_var(thd, this,
7383
1/2
✓ Branch 0 taken 360691 times.
✗ Branch 1 not taken.
 360690 GET_SYS_VAR_CACHE_STRING);
7384
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 360691 times.
 360691 assert(fixed);
7385
7386
3/4
✓ Branch 0 taken 267 times.
✓ Branch 1 taken 360424 times.
✓ Branch 2 taken 267 times.
✗ Branch 3 not taken.
 360691 if (cache_present && thd->query_id == used_query_id) {
7387
2/2
✓ Branch 0 taken 260 times.
✓ Branch 1 taken 7 times.
 267 if (cache_present & GET_SYS_VAR_CACHE_STRING) {
7388 260 null_value = cached_null_value;
7389
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 256 times.
 260 return null_value ? nullptr : &cached_strval;
7390
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 } else if (cache_present & GET_SYS_VAR_CACHE_LONG) {
7391 7 null_value = cached_null_value;
7392
2/4
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
 7 if (!null_value) cached_strval.set(cached_llval, collation.collation);
7393 7 cache_present |= GET_SYS_VAR_CACHE_STRING;
7394
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
 7 return null_value ? nullptr : &cached_strval;
7395 ✗ } else if (cache_present & GET_SYS_VAR_CACHE_DOUBLE) {
7396 ✗ null_value = cached_null_value;
7397 ✗ if (!null_value)
7398 ✗ cached_strval.set_real(cached_dval, decimals, collation.collation);
7399 ✗ cache_present |= GET_SYS_VAR_CACHE_STRING;
7400 ✗ return null_value ? nullptr : &cached_strval;
7401 }
7402 }
7403
7404 360424 str = &cached_strval;
7405 360424 null_value = false;
7406
7407 1412180 auto f = [this, thd, &str](const System_variable_tracker &, sys_var *var) {
7408
2/4
✓ Branch 0 taken 330655 times.
✓ Branch 1 taken 29763 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 360414 switch (var->show_type()) {
7409 330655 case SHOW_CHAR:
7410 case SHOW_CHAR_PTR:
7411 case SHOW_LEX_STRING: {
7412 330655 mysql_mutex_lock(&LOCK_global_system_variables);
7413 const char *cptr =
7414 330662 var->show_type() == SHOW_CHAR
7415
2/2
✓ Branch 0 taken 159614 times.
✓ Branch 1 taken 171048 times.
 661324 ? pointer_cast<const char *>(var->value_ptr(
7416 159614 thd, var_scope, var_tracker.get_keycache_name()))
7417 342096 : *pointer_cast<const char *const *>(var->value_ptr(
7418 171048 thd, var_scope, var_tracker.get_keycache_name()));
7419
2/2
✓ Branch 0 taken 330219 times.
✓ Branch 1 taken 443 times.
 330662 if (cptr) {
7420 size_t len =
7421 330219 var->show_type() == SHOW_LEX_STRING
7422
2/2
✓ Branch 0 taken 127 times.
✓ Branch 1 taken 330092 times.
 330346 ? (pointer_cast<const LEX_STRING *>(var->value_ptr(
7423 127 thd, var_scope, var_tracker.get_keycache_name())))
7424 ->length
7425 330092 : strlen(cptr);
7426
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 330219 times.
 330219 if (str->copy(cptr, len, collation.collation)) {
7427 ✗ null_value = true;
7428 ✗ str = nullptr;
7429 }
7430 } else {
7431 443 null_value = true;
7432 443 str = nullptr;
7433 }
7434 330662 mysql_mutex_unlock(&LOCK_global_system_variables);
7435 330662 break;
7436 }
7437
7438 29763 case SHOW_INT:
7439 case SHOW_LONG:
7440 case SHOW_LONGLONG:
7441 case SHOW_SIGNED_INT:
7442 case SHOW_SIGNED_LONG:
7443 case SHOW_SIGNED_LONGLONG:
7444 case SHOW_HA_ROWS:
7445 case SHOW_BOOL:
7446 case SHOW_MY_BOOL:
7447
2/2
✓ Branch 0 taken 29762 times.
✓ Branch 1 taken 1 times.
 29763 if (unsigned_flag)
7448 29762 str->set((ulonglong)val_int(), collation.collation);
7449 else
7450 1 str->set(val_int(), collation.collation);
7451 29763 break;
7452 ✗ case SHOW_DOUBLE:
7453 ✗ str->set_real(val_real(), decimals, collation.collation);
7454 ✗ break;
7455
7456 ✗ default:
7457 ✗ my_error(ER_VAR_CANT_BE_READ, MYF(0), var->name.str);
7458 ✗ str = error_str();
7459 ✗ break;
7460 }
7461 720849 };
7462
3/6
✓ Branch 0 taken 360418 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 360425 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 360425 times.
 360424 if (var_tracker.access_system_variable(thd, f)) {
7463 ✗ str = error_str();
7464 }
7465
7466 360425 cache_present |= GET_SYS_VAR_CACHE_STRING;
7467 360425 used_query_id = thd->query_id;
7468 360425 cached_null_value = null_value;
7469 360425 return str;
7470 360692 }
7471
7472 3332 double Item_func_get_system_var::val_real() {
7473
1/2
✓ Branch 0 taken 3332 times.
✗ Branch 1 not taken.
 3332 THD *thd = current_thd;
7474 Audit_global_variable_get_event audit_sys_var(thd, this,
7475
1/2
✓ Branch 0 taken 3332 times.
✗ Branch 1 not taken.
 3332 GET_SYS_VAR_CACHE_DOUBLE);
7476
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3332 times.
 3332 assert(fixed);
7477
7478
3/4
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3326 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
 3332 if (cache_present && thd->query_id == used_query_id) {
7479
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (cache_present & GET_SYS_VAR_CACHE_DOUBLE) {
7480 6 null_value = cached_null_value;
7481 6 return cached_dval;
7482 ✗ } else if (cache_present & GET_SYS_VAR_CACHE_LONG) {
7483 ✗ null_value = cached_null_value;
7484 ✗ cached_dval = (double)cached_llval;
7485 ✗ cache_present |= GET_SYS_VAR_CACHE_DOUBLE;
7486 ✗ return cached_dval;
7487 ✗ } else if (cache_present & GET_SYS_VAR_CACHE_STRING) {
7488 ✗ null_value = cached_null_value;
7489 ✗ if (!null_value)
7490 ✗ cached_dval = double_from_string_with_check(
7491 ✗ cached_strval.charset(), cached_strval.c_ptr(),
7492 ✗ cached_strval.c_ptr() + cached_strval.length());
7493 else
7494 ✗ cached_dval = 0;
7495 ✗ cache_present |= GET_SYS_VAR_CACHE_DOUBLE;
7496 ✗ return cached_dval;
7497 }
7498 }
7499
7500 3326 auto f = [this, thd](const System_variable_tracker &,
7501 7656 sys_var *var) -> double {
7502
3/4
✓ Branch 0 taken 330 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 2989 times.
✗ Branch 3 not taken.
 3326 switch (var->show_type()) {
7503 330 case SHOW_DOUBLE:
7504 330 mysql_mutex_lock(&LOCK_global_system_variables);
7505 990 cached_dval = *pointer_cast<const double *>(
7506 330 var->value_ptr(thd, var_scope, var_tracker.get_keycache_name()));
7507 330 mysql_mutex_unlock(&LOCK_global_system_variables);
7508 330 used_query_id = thd->query_id;
7509 330 cached_null_value = null_value;
7510
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 330 times.
 330 if (null_value) cached_dval = 0;
7511 330 cache_present |= GET_SYS_VAR_CACHE_DOUBLE;
7512 330 return cached_dval;
7513 7 case SHOW_CHAR:
7514 case SHOW_LEX_STRING:
7515 case SHOW_CHAR_PTR: {
7516 7 mysql_mutex_lock(&LOCK_global_system_variables);
7517 const char *cptr =
7518 7 var->show_type() == SHOW_CHAR
7519
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 14 ? pointer_cast<const char *>(var->value_ptr(
7520 7 thd, var_scope, var_tracker.get_keycache_name()))
7521 ✗ : *pointer_cast<const char *const *>(var->value_ptr(
7522 ✗ thd, var_scope, var_tracker.get_keycache_name()));
7523 // Treat empty strings as NULL, like val_int() does.
7524
3/4
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1 times.
 7 if (cptr && *cptr)
7525 6 cached_dval = double_from_string_with_check(system_charset_info, cptr,
7526 6 cptr + strlen(cptr));
7527 else {
7528 1 null_value = true;
7529 1 cached_dval = 0;
7530 }
7531 7 mysql_mutex_unlock(&LOCK_global_system_variables);
7532 7 used_query_id = thd->query_id;
7533 7 cached_null_value = null_value;
7534 7 cache_present |= GET_SYS_VAR_CACHE_DOUBLE;
7535 7 return cached_dval;
7536 }
7537 2989 case SHOW_INT:
7538 case SHOW_LONG:
7539 case SHOW_LONGLONG:
7540 case SHOW_SIGNED_INT:
7541 case SHOW_SIGNED_LONG:
7542 case SHOW_SIGNED_LONGLONG:
7543 case SHOW_HA_ROWS:
7544 case SHOW_BOOL:
7545 case SHOW_MY_BOOL:
7546 2989 cached_dval = (double)val_int();
7547 2989 cache_present |= GET_SYS_VAR_CACHE_DOUBLE;
7548 2989 used_query_id = thd->query_id;
7549 2989 cached_null_value = null_value;
7550 2989 return cached_dval;
7551 ✗ default:
7552 ✗ my_error(ER_VAR_CANT_BE_READ, MYF(0), var->name.str);
7553 ✗ return 0;
7554 }
7555 3326 };
7556
1/2
✓ Branch 0 taken 3326 times.
✗ Branch 1 not taken.
 3326 return var_tracker.access_system_variable<double>(thd, f).value_or(0);
7557 3332 }
7558
7559 ✗ bool Item_func_get_system_var::eq(const Item *item, bool) const {
7560 /* Assume we don't have rtti */
7561 ✗ if (this == item) return true; // Same item is same.
7562 /* Check if other type is also a get_user_var() object */
7563 ✗ if (item->type() != FUNC_ITEM ||
7564 ✗ down_cast<const Item_func *>(item)->functype() != functype())
7565 ✗ return false;
7566 const Item_func_get_system_var *other =
7567 ✗ down_cast<const Item_func_get_system_var *>(item);
7568 ✗ return var_tracker == other->var_tracker;
7569 }
7570
7571 629470 void Item_func_get_system_var::cleanup() {
7572 629470 Item_func::cleanup();
7573 629470 cache_present = 0;
7574 629470 cached_strval.mem_free();
7575 629470 }
7576
7577 2796 bool Item_func_match::itemize(Parse_context *pc, Item **res) {
7578
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2796 times.
 2796 if (skip_itemize(res)) return false;
7579
5/6
✓ Branch 0 taken 2792 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2792 times.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 2792 times.
 2796 if (super::itemize(pc, res) || against->itemize(pc, &against)) return true;
7580 2792 add_accum_properties(against);
7581
7582 2792 pc->select->add_ftfunc_to_list(this);
7583 2792 pc->thd->lex->set_using_match();
7584
7585
2/2
✓ Branch 0 taken 2523 times.
✓ Branch 1 taken 269 times.
 2792 switch (pc->select->parsing_place) {
7586 2523 case CTX_WHERE:
7587 case CTX_ON:
7588 2523 used_in_where_only = true;
7589 2523 break;
7590 269 default:
7591 269 used_in_where_only = false;
7592 }
7593
7594 2792 return false;
7595 }
7596
7597 /**
7598 Initialize searching within full-text index.
7599
7600 @param thd Thread handler
7601
7602 @returns false if success, true if error
7603 */
7604
7605 2776 bool Item_func_match::init_search(THD *thd) {
7606
1/2
✓ Branch 0 taken 2776 times.
✗ Branch 1 not taken.
 2776 DBUG_TRACE;
7607
7608 /*
7609 We will skip execution if the item is not fixed
7610 with fix_field
7611 */
7612
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2776 times.
 2776 if (!fixed) return false;
7613
7614 2776 TABLE *const table = table_ref->table;
7615 /* Check if init_search() has been called before */
7616
3/4
✓ Branch 0 taken 113 times.
✓ Branch 1 taken 2663 times.
✓ Branch 2 taken 113 times.
✗ Branch 3 not taken.
 2776 if (ft_handler && !master) {
7617 // Update handler::ft_handler even if the search is already initialized.
7618 // If the first call to init_search() was done before we had decided if
7619 // an index scan should be used, and we later decide that we will use
7620 // one, ft_handler is not set. For example, the optimizer calls
7621 // init_search() early if it needs to call Item_func_match::get_count()
7622 // to perform COUNT(*) optimization or decide if a LIMIT clause can be
7623 // satisfied by an index scan.
7624
2/2
✓ Branch 0 taken 98 times.
✓ Branch 1 taken 15 times.
 113 if (score_from_index_scan) table->file->ft_handler = ft_handler;
7625 113 return false;
7626 }
7627
7628
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 2637 times.
 2663 if (key == NO_SUCH_KEY) {
7629 26 mem_root_deque<Item *> fields(thd->mem_root);
7630
3/6
✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 26 times.
✗ Branch 5 not taken.
 26 fields.push_back(new Item_string(" ", 1, cmp_collation.collation));
7631
3/4
✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 26 times.
 59 for (uint i = 0; i < arg_count; i++) fields.push_back(args[i]);
7632
2/4
✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
 26 concat_ws = new Item_func_concat_ws(&fields);
7633
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
 26 if (concat_ws == nullptr) return true;
7634 /*
7635 Above function used only to get value and do not need fix_fields for it:
7636 Item_string - basic constant
7637 fields - fix_fields() was already called for this arguments
7638 Item_func_concat_ws - do not need fix_fields() to produce value
7639 */
7640 26 concat_ws->quick_fix_field();
7641
1/2
✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
 26 }
7642
7643
2/2
✓ Branch 0 taken 94 times.
✓ Branch 1 taken 2569 times.
 2663 if (master) {
7644
2/4
✓ Branch 0 taken 94 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 94 times.
 94 if (master->init_search(thd)) return true;
7645
7646 94 ft_handler = master->ft_handler;
7647 94 return false;
7648 }
7649
7650 2569 String *ft_tmp = nullptr;
7651
7652 // MATCH ... AGAINST (NULL) is meaningless, but possible
7653
3/4
✓ Branch 0 taken 2569 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 2566 times.
 2569 if (!(ft_tmp = key_item()->val_str(&value))) {
7654 3 ft_tmp = &value;
7655
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 value.set("", 0, cmp_collation.collation);
7656 }
7657
7658
2/2
✓ Branch 0 taken 1290 times.
✓ Branch 1 taken 1279 times.
 2569 if (ft_tmp->charset() != cmp_collation.collation) {
7659 uint dummy_errors;
7660
1/2
✓ Branch 0 taken 1290 times.
✗ Branch 1 not taken.
 1290 search_value.copy(ft_tmp->ptr(), ft_tmp->length(), ft_tmp->charset(),
7661 cmp_collation.collation, &dummy_errors);
7662 1290 ft_tmp = &search_value;
7663 }
7664
7665
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2569 times.
 2569 if (!table->is_created()) {
7666 ✗ my_error(ER_NO_FT_MATERIALIZED_SUBQUERY, MYF(0));
7667 ✗ return true;
7668 }
7669
7670
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2569 times.
 2569 assert(master == nullptr);
7671
1/2
✓ Branch 0 taken 2569 times.
✗ Branch 1 not taken.
 2569 ft_handler = table->file->ft_init_ext_with_hints(key, ft_tmp, get_hints());
7672
7/8
✓ Branch 0 taken 2562 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 2562 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 2560 times.
✓ Branch 6 taken 9 times.
✓ Branch 7 taken 2560 times.
 2569 if (ft_handler == nullptr || thd->is_error()) {
7673 9 return true;
7674 }
7675
7676
2/2
✓ Branch 0 taken 2133 times.
✓ Branch 1 taken 427 times.
 2560 if (score_from_index_scan) table->file->ft_handler = ft_handler;
7677
7678 2560 return false;
7679 2776 }
7680
7681 339 float Item_func_match::get_filtering_effect(THD *, table_map filter_for_table,
7682 table_map read_tables,
7683 const MY_BITMAP *fields_to_ignore,
7684 double rows_in_table) {
7685 const Item_field *fld =
7686 339 contributes_to_filter(read_tables, filter_for_table, fields_to_ignore);
7687
2/2
✓ Branch 0 taken 172 times.
✓ Branch 1 taken 167 times.
 339 if (!fld) return COND_FILTER_ALLPASS;
7688
7689 /*
7690 MATCH () ... AGAINST" is similar to "LIKE '...'" which has the
7691 same selectivity as "col BETWEEN ...".
7692 */
7693 167 return fld->get_cond_filter_default_probability(rows_in_table,
7694 167 COND_FILTER_BETWEEN);
7695 }
7696
7697 /**
7698 Add field into table read set.
7699
7700 @param field field to be added to the table read set.
7701 */
7702 3789 static void update_table_read_set(const Field *field) {
7703 3789 TABLE *table = field->table;
7704
7705
2/2
✓ Branch 0 taken 594 times.
✓ Branch 1 taken 3195 times.
 3789 if (!bitmap_test_and_set(table->read_set, field->field_index()))
7706 594 table->covering_keys.intersect(field->part_of_key);
7707 3789 }
7708
7709 2776 bool Item_func_match::fix_fields(THD *thd, Item **ref) {
7710
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2776 times.
 2776 assert(fixed == 0);
7711
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2776 times.
 2776 assert(arg_count > 0);
7712 2776 Item *item = nullptr; // Safe as arg_count is > 1
7713
7714 2776 set_nullable(true);
7715
7716 /*
7717 const_item is assumed in quite a bit of places, so it would be difficult
7718 to remove; If it would ever to be removed, this should include
7719 modifications to find_best and auto_close as complement to auto_init code
7720 above.
7721 */
7722 2776 enum_mark_columns save_mark_used_columns = thd->mark_used_columns;
7723 /*
7724 Since different engines require different columns for FTS index lookup
7725 we prevent updating of table read_set in argument's ::fix_fields().
7726 */
7727 2776 thd->mark_used_columns = MARK_COLUMNS_NONE;
7728
4/6
✓ Branch 0 taken 2776 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2776 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 2774 times.
 5552 if (Item_func::fix_fields(thd, ref) || fix_func_arg(thd, &against) ||
7729
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2774 times.
 2776 !against->const_for_execution()) {
7730 2 thd->mark_used_columns = save_mark_used_columns;
7731 2 my_error(ER_WRONG_ARGUMENTS, MYF(0), "AGAINST");
7732 2 return true;
7733 }
7734 2774 thd->mark_used_columns = save_mark_used_columns;
7735
7736
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2774 times.
 2774 if (against->propagate_type(thd)) return true;
7737
7738 2774 bool allows_multi_table_search = true;
7739
2/2
✓ Branch 0 taken 4103 times.
✓ Branch 1 taken 2767 times.
 6870 for (uint i = 0; i < arg_count; i++) {
7740 4103 item = args[i] = args[i]->real_item();
7741
4/4
✓ Branch 0 taken 4101 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 4096 times.
 8204 if (item->type() != Item::FIELD_ITEM ||
7742 /* Cannot use FTS index with outer table field */
7743
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 4096 times.
 4101 item->is_outer_reference()) {
7744 7 my_error(ER_WRONG_ARGUMENTS, MYF(0), "MATCH");
7745 7 return true;
7746 }
7747 4096 allows_multi_table_search &= allows_search_on_non_indexed_columns(
7748 4096 ((Item_field *)item)->field->table);
7749 }
7750
7751 /*
7752 Check that all columns come from the same table.
7753 We've already checked that columns in MATCH are fields so
7754 INNER_TABLE_BIT can only appear from AGAINST argument.
7755 */
7756
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2759 times.
 2767 if ((used_tables_cache & ~INNER_TABLE_BIT) != item->used_tables())
7757 8 key = NO_SUCH_KEY;
7758
7759
4/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2759 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 3 times.
 2767 if (key == NO_SUCH_KEY && !allows_multi_table_search) {
7760 5 my_error(ER_WRONG_ARGUMENTS, MYF(0), "MATCH");
7761 5 return true;
7762 }
7763 2762 table_ref = ((Item_field *)item)->table_ref;
7764
7765
1/2
✓ Branch 0 taken 2762 times.
✗ Branch 1 not taken.
 2762 if (table_ref != nullptr) table_ref->set_fulltext_searched();
7766
7767 /*
7768 Here we make an assumption that if the engine supports
7769 fulltext extension(HA_CAN_FULLTEXT_EXT flag) then table
7770 can have FTS_DOC_ID column. Atm this is the only way
7771 to distinguish MyISAM and InnoDB engines.
7772 Generally table_ref should be available, but in case of
7773 a generated column's generation expression it's not. Thus
7774 we use field's table, at this moment it's already available.
7775 */
7776 2762 TABLE *const table =
7777
1/2
✓ Branch 0 taken 2762 times.
✗ Branch 1 not taken.
 2762 table_ref ? table_ref->table : ((Item_field *)item)->field->table;
7778
7779
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 2749 times.
 2762 if (!(table->file->ha_table_flags() & HA_CAN_FULLTEXT)) {
7780 13 my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0));
7781 13 return true;
7782 }
7783
7784
2/2
✓ Branch 0 taken 2363 times.
✓ Branch 1 taken 386 times.
 2749 if ((table->file->ha_table_flags() & HA_CAN_FULLTEXT_EXT)) {
7785 2363 Field *doc_id_field = table->fts_doc_id_field;
7786 /*
7787 Update read set with FTS_DOC_ID column so that indexes that have
7788 FTS_DOC_ID part can be considered as a covering index.
7789 */
7790
2/2
✓ Branch 0 taken 343 times.
✓ Branch 1 taken 2020 times.
 2363 if (doc_id_field)
7791 343 update_table_read_set(doc_id_field);
7792 else {
7793 /* read_set needs to be updated for MATCH arguments */
7794
2/2
✓ Branch 0 taken 2969 times.
✓ Branch 1 taken 2020 times.
 4989 for (uint i = 0; i < arg_count; i++)
7795 2969 update_table_read_set(((Item_field *)args[i])->field);
7796 /*
7797 Prevent index only access by non-FTS index if table does not have
7798 FTS_DOC_ID column, find_relevance does not work properly without
7799 FTS_DOC_ID value. Decision for FTS index about index only access
7800 is made later by JOIN::fts_index_access() function.
7801 */
7802 2020 table->covering_keys.clear_all();
7803 }
7804
7805 } else {
7806 /*
7807 Since read_set is not updated for MATCH arguments
7808 it's necessary to update it here for MyISAM.
7809 */
7810
2/2
✓ Branch 0 taken 477 times.
✓ Branch 1 taken 386 times.
 863 for (uint i = 0; i < arg_count; i++)
7811 477 update_table_read_set(((Item_field *)args[i])->field);
7812 }
7813
7814
1/2
✓ Branch 0 taken 2749 times.
✗ Branch 1 not taken.
 2749 if (!master) {
7815
1/2
✓ Branch 0 taken 2749 times.
✗ Branch 1 not taken.
 2749 Prepared_stmt_arena_holder ps_arena_holder(thd);
7816
1/2
✓ Branch 0 taken 2749 times.
✗ Branch 1 not taken.
 2749 hints = new (thd->mem_root) Ft_hints(flags);
7817
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2749 times.
 2749 if (!hints) {
7818 ✗ my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0));
7819 ✗ return true;
7820 }
7821
1/2
✓ Branch 0 taken 2749 times.
✗ Branch 1 not taken.
 2749 }
7822 2749 return agg_item_collations_for_comparison(cmp_collation, func_name(), args,
7823 2749 arg_count, 0);
7824 }
7825
7826 2739 bool Item_func_match::fix_index(const THD *thd) {
7827 TABLE *table;
7828 2739 uint ft_to_key[MAX_KEY], ft_cnt[MAX_KEY], fts = 0, keynr;
7829 2739 uint max_cnt = 0, mkeys = 0, i;
7830
7831
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2739 times.
 2739 if (!table_ref) goto err;
7832
7833 /*
7834 We will skip execution if the item is not fixed
7835 with fix_field
7836 */
7837
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2739 times.
 2739 if (!fixed) {
7838 ✗ if (allows_search_on_non_indexed_columns(table_ref->table))
7839 ✗ key = NO_SUCH_KEY;
7840
7841 ✗ return false;
7842 }
7843
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2736 times.
 2739 if (key == NO_SUCH_KEY) return false;
7844
7845 2736 table = table_ref->table;
7846
2/2
✓ Branch 0 taken 10168 times.
✓ Branch 1 taken 2736 times.
 12904 for (keynr = 0; keynr < table->s->keys; keynr++) {
7847
2/2
✓ Branch 0 taken 8090 times.
✓ Branch 1 taken 2078 times.
 18258 if ((table->key_info[keynr].flags & HA_FULLTEXT) &&
7848
4/4
✓ Branch 0 taken 4525 times.
✓ Branch 1 taken 3565 times.
✓ Branch 2 taken 4515 times.
✓ Branch 3 taken 10 times.
 8090 (flags & FT_BOOL ? table->keys_in_use_for_query.is_set(keynr)
7849
5/6
✓ Branch 0 taken 3565 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3562 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 8077 times.
✓ Branch 5 taken 2091 times.
 13733 : table->s->usable_indexes(thd).is_set(keynr)))
7850
7851 {
7852 8077 ft_to_key[fts] = keynr;
7853 8077 ft_cnt[fts] = 0;
7854 8077 fts++;
7855 }
7856 }
7857
7858
2/2
✓ Branch 0 taken 41 times.
✓ Branch 1 taken 2695 times.
 2736 if (!fts) goto err;
7859
7860
2/2
✓ Branch 0 taken 4004 times.
✓ Branch 1 taken 2695 times.
 6699 for (i = 0; i < arg_count; i++) {
7861 Item_field *item =
7862
2/4
✓ Branch 0 taken 4004 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4004 times.
✗ Branch 3 not taken.
 4004 down_cast<Item_field *>(unwrap_rollup_group(args[i])->real_item());
7863
2/2
✓ Branch 0 taken 10883 times.
✓ Branch 1 taken 4004 times.
 14887 for (keynr = 0; keynr < fts; keynr++) {
7864 10883 KEY *ft_key = &table->key_info[ft_to_key[keynr]];
7865 10883 uint key_parts = ft_key->user_defined_key_parts;
7866
7867
2/2
✓ Branch 0 taken 14726 times.
✓ Branch 1 taken 10883 times.
 25609 for (uint part = 0; part < key_parts; part++) {
7868
3/4
✓ Branch 0 taken 14726 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4769 times.
✓ Branch 3 taken 9957 times.
 14726 if (item->field->eq(ft_key->key_part[part].field)) ft_cnt[keynr]++;
7869 }
7870 }
7871 }
7872
7873
2/2
✓ Branch 0 taken 8077 times.
✓ Branch 1 taken 2695 times.
 10772 for (keynr = 0; keynr < fts; keynr++) {
7874
2/2
✓ Branch 0 taken 2818 times.
✓ Branch 1 taken 5259 times.
 8077 if (ft_cnt[keynr] > max_cnt) {
7875 2818 mkeys = 0;
7876 2818 max_cnt = ft_cnt[mkeys] = ft_cnt[keynr];
7877 2818 ft_to_key[mkeys] = ft_to_key[keynr];
7878 2818 continue;
7879 }
7880
4/4
✓ Branch 0 taken 3068 times.
✓ Branch 1 taken 2191 times.
✓ Branch 2 taken 400 times.
✓ Branch 3 taken 2668 times.
 5259 if (max_cnt && ft_cnt[keynr] == max_cnt) {
7881 400 mkeys++;
7882 400 ft_cnt[mkeys] = ft_cnt[keynr];
7883 400 ft_to_key[mkeys] = ft_to_key[keynr];
7884 400 continue;
7885 }
7886 }
7887
7888
2/2
✓ Branch 0 taken 2751 times.
✓ Branch 1 taken 12 times.
 2763 for (keynr = 0; keynr <= mkeys; keynr++) {
7889 // partial keys doesn't work
7890
2/2
✓ Branch 0 taken 2741 times.
✓ Branch 1 taken 10 times.
 2751 if (max_cnt < arg_count ||
7891
2/2
✓ Branch 0 taken 58 times.
✓ Branch 1 taken 2683 times.
 2741 max_cnt < table->key_info[ft_to_key[keynr]].user_defined_key_parts)
7892 68 continue;
7893
7894 2683 key = ft_to_key[keynr];
7895
7896 2683 return false;
7897 }
7898
7899 12 err:
7900
5/6
✓ Branch 0 taken 53 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
✓ Branch 3 taken 30 times.
✓ Branch 4 taken 23 times.
✓ Branch 5 taken 30 times.
 106 if (table_ref != nullptr &&
7901 53 allows_search_on_non_indexed_columns(table_ref->table)) {
7902 23 key = NO_SUCH_KEY;
7903 23 return false;
7904 }
7905
1/2
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
 30 my_error(ER_FT_MATCHING_KEY_NOT_FOUND, MYF(0));
7906 30 return true;
7907 }
7908
7909 696 bool Item_func_match::eq(const Item *item, bool binary_cmp) const {
7910 /* We ignore FT_SORTED flag when checking for equality since result is
7911 equivalent regardless of sorting */
7912
4/4
✓ Branch 0 taken 357 times.
✓ Branch 1 taken 339 times.
✓ Branch 2 taken 366 times.
✓ Branch 3 taken 330 times.
 1053 if (!is_function_of_type(item, FT_FUNC) ||
7913 357 (flags | FT_SORTED) !=
7914
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 330 times.
 357 (down_cast<const Item_func_match *>(item)->flags | FT_SORTED))
7915 366 return false;
7916
7917 330 const Item_func_match *ifm = down_cast<const Item_func_match *>(item);
7918
7919
6/6
✓ Branch 0 taken 327 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 304 times.
✓ Branch 3 taken 23 times.
✓ Branch 4 taken 248 times.
✓ Branch 5 taken 82 times.
 634 if (key == ifm->key && table_ref == ifm->table_ref &&
7920
2/2
✓ Branch 0 taken 248 times.
✓ Branch 1 taken 56 times.
 304 key_item()->eq(ifm->key_item(), binary_cmp))
7921 248 return true;
7922
7923 82 return false;
7924 }
7925
7926 28605 double Item_func_match::val_real() {
7927
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28605 times.
 28605 assert(fixed);
7928
7929 // MATCH only knows how to get the score for base columns. Other types of
7930 // expressions (such as function calls or rollup columns) should have been
7931 // rejected during resolving.
7932
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28605 times.
 28605 assert(!has_rollup_expr());
7933
2/4
✓ Branch 0 taken 28605 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 28605 times.
 61311 assert(std::all_of(args, args + arg_count, [](const Item *item) {
7934 return item->real_item()->type() == FIELD_ITEM;
7935 }));
7936
7937
1/2
✓ Branch 0 taken 28605 times.
✗ Branch 1 not taken.
 28605 DBUG_TRACE;
7938
2/2
✓ Branch 0 taken 2173 times.
✓ Branch 1 taken 26432 times.
 28605 if (ft_handler == nullptr) return -1.0;
7939
7940 26432 TABLE *const table = table_ref->table;
7941
6/6
✓ Branch 0 taken 26384 times.
✓ Branch 1 taken 48 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 26379 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 26427 times.
 26432 if (key != NO_SUCH_KEY && table->has_null_row()) // NULL row from outer join
7942 5 return 0.0;
7943
7944
3/4
✓ Branch 0 taken 26427 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16451 times.
✓ Branch 3 taken 9976 times.
 26427 if (get_master()->score_from_index_scan) {
7945
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16451 times.
 16451 assert(table->file->ft_handler == ft_handler);
7946
1/2
✓ Branch 0 taken 16451 times.
✗ Branch 1 not taken.
 16451 return ft_handler->please->get_relevance(ft_handler);
7947 }
7948
7949
2/2
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 9928 times.
 9976 if (key == NO_SUCH_KEY) {
7950
1/2
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
 48 String *a = concat_ws->val_str(&value);
7951
5/6
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 47 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 47 times.
 48 if ((null_value = (a == nullptr)) || !a->length()) return 0;
7952
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
 47 return ft_handler->please->find_relevance(ft_handler, (uchar *)a->ptr(),
7953 94 a->length());
7954 }
7955
1/2
✓ Branch 0 taken 9928 times.
✗ Branch 1 not taken.
 9928 return ft_handler->please->find_relevance(ft_handler, table->record[0], 0);
7956 28605 }
7957
7958 561 void Item_func_match::print(const THD *thd, String *str,
7959 enum_query_type query_type) const {
7960 561 str->append(STRING_WITH_LEN("(match "));
7961 561 print_args(thd, str, 0, query_type);
7962 561 str->append(STRING_WITH_LEN(" against ("));
7963 561 against->print(thd, str, query_type);
7964
2/2
✓ Branch 0 taken 125 times.
✓ Branch 1 taken 436 times.
 561 if (flags & FT_BOOL)
7965 125 str->append(STRING_WITH_LEN(" in boolean mode"));
7966
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 424 times.
 436 else if (flags & FT_EXPAND)
7967 12 str->append(STRING_WITH_LEN(" with query expansion"));
7968 561 str->append(STRING_WITH_LEN("))"));
7969 561 }
7970
7971 /**
7972 Function sets FT hints(LIMIT, flags) depending on
7973 various join conditions.
7974
7975 @param join Pointer to JOIN object.
7976 @param ft_flag FT flag value.
7977 @param ft_limit Limit value.
7978 @param no_cond true if MATCH is not used in WHERE condition.
7979 */
7980
7981 2344 void Item_func_match::set_hints(JOIN *join, uint ft_flag, ha_rows ft_limit,
7982 bool no_cond) {
7983
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2344 times.
 2344 assert(!master);
7984
7985
2/2
✓ Branch 0 taken 143 times.
✓ Branch 1 taken 2201 times.
 2344 if (!join) // used for count() optimization
7986 {
7987 143 hints->set_hint_flag(ft_flag);
7988 143 return;
7989 }
7990
7991 /* skip hints setting if there are aggregates(except of FT_NO_RANKING) */
7992
6/6
✓ Branch 0 taken 2000 times.
✓ Branch 1 taken 201 times.
✓ Branch 2 taken 1993 times.
✓ Branch 3 taken 7 times.
✓ Branch 4 taken 214 times.
✓ Branch 5 taken 1987 times.
 4194 if (join->implicit_grouping || !join->group_list.empty() ||
7993
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1987 times.
 1993 join->select_distinct) {
7994 /* 'No ranking' is possible even if aggregates are present */
7995
2/2
✓ Branch 0 taken 131 times.
✓ Branch 1 taken 83 times.
 214 if ((ft_flag & FT_NO_RANKING)) hints->set_hint_flag(FT_NO_RANKING);
7996 214 return;
7997 }
7998
7999 1987 hints->set_hint_flag(ft_flag);
8000
8001 /**
8002 Only one table is used, there is no aggregates,
8003 WHERE condition is a single MATCH expression
8004 (WHERE MATCH(..) or WHERE MATCH(..) [>=,>] value) or
8005 there is no WHERE condition.
8006 */
8007
8/8
✓ Branch 0 taken 1968 times.
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 1958 times.
✓ Branch 3 taken 10 times.
✓ Branch 4 taken 1933 times.
✓ Branch 5 taken 25 times.
✓ Branch 6 taken 1943 times.
✓ Branch 7 taken 44 times.
 1987 if (join->primary_tables == 1 && (no_cond || is_simple_expression()))
8008 1943 hints->set_hint_limit(ft_limit);
8009 }
8010
8011 /***************************************************************************
8012 System variables
8013 ****************************************************************************/
8014
8015 /**
8016 Return value of an system variable base[.name] as a constant item.
8017
8018 @param pc Current parse context
8019 @param scope Global / session
8020 @param prefix Optional prefix part of the variable name
8021 @param suffix Trivial name of suffix part of the variable name
8022 @param unsafe_for_replication If true and if the variable is written to a
8023 binlog then mark the statement as unsafe.
8024
8025 @note
8026 If component.str = 0 then the variable name is in 'name'
8027
8028 @return
8029 - 0 : error
8030 - # : constant item
8031 */
8032
8033 677902 Item *get_system_variable(Parse_context *pc, enum_var_type scope,
8034 const LEX_CSTRING &prefix, const LEX_CSTRING &suffix,
8035 bool unsafe_for_replication) {
8036 677902 THD *thd = pc->thd;
8037
8038 enum_var_type resolved_scope;
8039 677902 bool written_to_binlog_flag = false;
8040 677749 auto f = [thd, scope, &resolved_scope, &written_to_binlog_flag](
8041 3048346 const System_variable_tracker &, sys_var *v) -> bool {
8042
2/2
✓ Branch 0 taken 339101 times.
✓ Branch 1 taken 338648 times.
 677749 if (scope == OPT_DEFAULT) {
8043
2/2
✓ Branch 0 taken 73238 times.
✓ Branch 1 taken 265863 times.
 339101 if (v->check_scope(OPT_SESSION)) {
8044 73238 resolved_scope = OPT_SESSION;
8045 } else {
8046 /* As there was no local variable, return the global value */
8047
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 265863 times.
 265863 assert(v->check_scope(OPT_GLOBAL));
8048 265863 resolved_scope = OPT_GLOBAL;
8049 }
8050
2/2
✓ Branch 0 taken 337999 times.
✓ Branch 1 taken 649 times.
 338648 } else if (v->check_scope(scope)) {
8051 337999 resolved_scope = scope;
8052 } else {
8053
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 622 times.
 649 my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0), v->name.str,
8054 scope == OPT_GLOBAL ? "SESSION" : "GLOBAL");
8055 649 return true;
8056 }
8057
8058 677100 written_to_binlog_flag = v->is_written_to_binlog(resolved_scope);
8059 677100 v->do_deprecated_warning(thd);
8060 677100 return false;
8061 677902 };
8062 System_variable_tracker var_tracker = System_variable_tracker::make_tracker(
8063
1/2
✓ Branch 0 taken 677902 times.
✗ Branch 1 not taken.
 677902 to_string_view(prefix), to_string_view(suffix));
8064
4/6
✓ Branch 0 taken 677903 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 677903 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 803 times.
✓ Branch 5 taken 677100 times.
 677902 if (var_tracker.access_system_variable<bool>(thd, f).value_or(true)) {
8065 803 return nullptr;
8066 }
8067
8068
4/4
✓ Branch 0 taken 671023 times.
✓ Branch 1 taken 6077 times.
✓ Branch 2 taken 659919 times.
✓ Branch 3 taken 11104 times.
 677100 if (unsafe_for_replication && !written_to_binlog_flag)
8069
1/2
✓ Branch 0 taken 659919 times.
✗ Branch 1 not taken.
 659919 thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_VARIABLE);
8070
8071 677100 thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT);
8072
8073
2/4
✓ Branch 0 taken 677100 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 677099 times.
✗ Branch 3 not taken.
 677100 return new Item_func_get_system_var(var_tracker, resolved_scope);
8074 677902 }
8075
8076 4922 bool Item_func_row_count::itemize(Parse_context *pc, Item **res) {
8077
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4922 times.
 4922 if (skip_itemize(res)) return false;
8078
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4922 times.
 4922 if (super::itemize(pc, res)) return true;
8079
8080 4922 LEX *lex = pc->thd->lex;
8081 4922 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
8082 4922 lex->safe_to_cache_query = false;
8083 4922 return false;
8084 }
8085
8086 246 longlong Item_func_row_count::val_int() {
8087
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 246 times.
 246 assert(fixed == 1);
8088 246 THD *thd = current_thd;
8089
8090 246 return thd->get_row_count_func();
8091 }
8092
8093 220340 Item_func_sp::Item_func_sp(const POS &pos, const LEX_STRING &db_name,
8094 const LEX_STRING &fn_name, bool use_explicit_name,
8095 220340 PT_item_list *opt_list)
8096 220340 : Item_func(pos, opt_list) {
8097 /*
8098 Set to false here, which is the default according to SQL standard.
8099 RETURNS NULL ON NULL INPUT can be implemented by modifying this member.
8100 */
8101 220340 null_on_null = false;
8102 220340 set_nullable(true);
8103 220340 set_stored_program();
8104
1/2
✓ Branch 0 taken 220340 times.
✗ Branch 1 not taken.
 220340 THD *thd = current_thd;
8105 220340 m_name = new (thd->mem_root)
8106
1/2
✓ Branch 0 taken 220340 times.
✗ Branch 1 not taken.
 220340 sp_name(to_lex_cstring(db_name), fn_name, use_explicit_name);
8107 220340 }
8108
8109 220340 bool Item_func_sp::itemize(Parse_context *pc, Item **res) {
8110
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 220340 times.
 220340 if (skip_itemize(res)) return false;
8111
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 220338 times.
 220340 if (super::itemize(pc, res)) return true;
8112
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 220338 times.
 220338 if (m_name == nullptr) return true; // OOM
8113
8114 220338 THD *thd = pc->thd;
8115 220338 LEX *lex = thd->lex;
8116
8117 220338 context = lex->current_context();
8118 220338 lex->safe_to_cache_query = false;
8119
8120
2/2
✓ Branch 0 taken 79518 times.
✓ Branch 1 taken 140820 times.
 220338 if (m_name->m_db.str == nullptr) {
8121
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 79516 times.
 79518 if (thd->lex->copy_db_to(&m_name->m_db.str, &m_name->m_db.length)) {
8122 2 my_error(ER_NO_DB_ERROR, MYF(0));
8123 2 return true;
8124 }
8125 }
8126
8127 220336 m_name->init_qname(thd);
8128
2/4
✓ Branch 0 taken 220336 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 220336 times.
✗ Branch 3 not taken.
 220336 sp_add_own_used_routine(lex, thd, Sroutine_hash_entry::FUNCTION, m_name);
8129
8130 220336 return false;
8131 }
8132
8133 322483 void Item_func_sp::cleanup() {
8134
2/2
✓ Branch 0 taken 318366 times.
✓ Branch 1 taken 4117 times.
 322483 if (sp_result_field != nullptr) {
8135 318366 sp_result_field->mem_free();
8136 318366 sp_result_field->table->in_use = nullptr;
8137 }
8138 322483 m_sp = nullptr;
8139 322483 Item_func::cleanup();
8140 322483 }
8141
8142 136822 const char *Item_func_sp::func_name() const {
8143
1/2
✓ Branch 0 taken 136822 times.
✗ Branch 1 not taken.
 136822 const THD *thd = current_thd;
8144 /* Calculate length to avoid reallocation of string for sure */
8145 136822 size_t len =
8146
2/2
✓ Branch 0 taken 133233 times.
✓ Branch 1 taken 3589 times.
 136822 (((m_name->m_explicit_name ? m_name->m_db.length : 0) +
8147 136822 m_name->m_name.length) *
8148 136822 2 + // characters*quoting
8149 136822 2 + // ` and `
8150
2/2
✓ Branch 0 taken 133233 times.
✓ Branch 1 taken 3589 times.
 136822 (m_name->m_explicit_name ? 3 : 0) + // '`', '`' and '.' for the db
8151 1 + // end of string
8152 ALIGN_SIZE(1)); // to avoid String reallocation
8153
1/2
✓ Branch 0 taken 136822 times.
✗ Branch 1 not taken.
 136822 String qname((char *)thd->mem_root->Alloc(len), len, system_charset_info);
8154
8155 136822 qname.length(0);
8156
2/2
✓ Branch 0 taken 133233 times.
✓ Branch 1 taken 3589 times.
 136822 if (m_name->m_explicit_name) {
8157
1/2
✓ Branch 0 taken 133233 times.
✗ Branch 1 not taken.
 133233 append_identifier(thd, &qname, m_name->m_db.str, m_name->m_db.length);
8158
1/2
✓ Branch 0 taken 133233 times.
✗ Branch 1 not taken.
 133233 qname.append('.');
8159 }
8160
1/2
✓ Branch 0 taken 136822 times.
✗ Branch 1 not taken.
 136822 append_identifier(thd, &qname, m_name->m_name.str, m_name->m_name.length);
8161 273644 return qname.ptr();
8162 136822 }
8163
8164 180166 table_map Item_func_sp::get_initial_pseudo_tables() const {
8165 /*
8166 INNER_TABLE_BIT prevents function from being evaluated in preparation phase.
8167 @todo - make this dependent on READS SQL or MODIFIES SQL.
8168 Due to bug#26422182, a function cannot be executed before tables
8169 are locked, even though it accesses no tables.
8170 */
8171
2/2
✓ Branch 0 taken 151417 times.
✓ Branch 1 taken 28749 times.
 180166 return m_deterministic ? INNER_TABLE_BIT : RAND_TABLE_BIT;
8172 }
8173
8174 81 static void my_missing_function_error(const LEX_STRING &token,
8175 const char *func_name) {
8176
5/6
✓ Branch 0 taken 81 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 80 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 80 times.
 81 if (token.length && is_lex_native_function(&token))
8177 1 my_error(ER_FUNC_INEXISTENT_NAME_COLLISION, MYF(0), func_name);
8178 else
8179 80 my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "FUNCTION", func_name);
8180 81 }
8181
8182 /**
8183 @brief Initialize the result field by creating a temporary dummy table
8184 and assign it to a newly created field object. Meta data used to
8185 create the field is fetched from the sp_head belonging to the stored
8186 procedure found in the stored procedure function cache.
8187
8188 @note This function should be called from fix_fields to init the result
8189 field. It is some what related to Item_field.
8190
8191 @see Item_field
8192
8193 @param thd A pointer to the session and thread context.
8194
8195 @return Function return error status.
8196 @retval true is returned on an error
8197 @retval false is returned on success.
8198 */
8199
8200 170232 bool Item_func_sp::init_result_field(THD *thd) {
8201 170232 LEX_CSTRING empty_name = {STRING_WITH_LEN("")};
8202
1/2
✓ Branch 0 taken 170232 times.
✗ Branch 1 not taken.
 170232 DBUG_TRACE;
8203
8204
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 170232 times.
 170232 assert(m_sp == nullptr);
8205
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 170232 times.
 170232 assert(sp_result_field == nullptr);
8206
8207 Internal_error_handler_holder<View_error_handler, TABLE_LIST> view_handler(
8208
1/2
✓ Branch 0 taken 170232 times.
✗ Branch 1 not taken.
 170232 thd, context->view_error_handler, context->view_error_handler_arg);
8209
1/2
✓ Branch 0 taken 170232 times.
✗ Branch 1 not taken.
 170232 m_sp = sp_find_routine(thd, enum_sp_type::FUNCTION, m_name,
8210 &thd->sp_func_cache, true);
8211
2/2
✓ Branch 0 taken 81 times.
✓ Branch 1 taken 170151 times.
 170232 if (m_sp == nullptr) {
8212
1/2
✓ Branch 0 taken 81 times.
✗ Branch 1 not taken.
 81 my_missing_function_error(m_name->m_name, m_name->m_qname.str);
8213 81 return true;
8214 }
8215
8216 170151 m_deterministic = m_sp->m_chistics->detistic;
8217
8218 /*
8219 A Field need to be attached to a Table.
8220 Below we "create" a dummy table by initializing
8221 the needed pointers.
8222 */
8223
2/4
✓ Branch 0 taken 170151 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 170151 times.
✗ Branch 3 not taken.
 170151 TABLE *dummy_table = new (thd->mem_root) TABLE;
8224
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 170151 times.
 170151 if (dummy_table == nullptr) return true;
8225
2/4
✓ Branch 0 taken 170151 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 170151 times.
✗ Branch 3 not taken.
 170151 TABLE_SHARE *share = new (thd->mem_root) TABLE_SHARE;
8226
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 170151 times.
 170151 if (share == nullptr) return true;
8227
8228 170151 dummy_table->s = share;
8229 170151 dummy_table->alias = "";
8230
1/2
✓ Branch 0 taken 170151 times.
✗ Branch 1 not taken.
 170151 if (is_nullable()) dummy_table->set_nullable();
8231 170151 dummy_table->in_use = thd;
8232 170151 dummy_table->copy_blobs = true;
8233 170151 share->table_cache_key = empty_name;
8234 170151 share->db = empty_name;
8235 170151 share->table_name = empty_name;
8236
8237 170151 sp_result_field =
8238
1/2
✓ Branch 0 taken 170151 times.
✗ Branch 1 not taken.
 170151 m_sp->create_result_field(thd, max_length, item_name.ptr(), dummy_table);
8239 170151 return sp_result_field == nullptr;
8240 170232 }
8241
8242 /**
8243 @brief Initialize local members with values from the Field interface.
8244
8245 @note called from Item::fix_fields.
8246 */
8247
8248 170146 bool Item_func_sp::resolve_type(THD *) {
8249
1/2
✓ Branch 0 taken 170146 times.
✗ Branch 1 not taken.
 170146 DBUG_TRACE;
8250
8251
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 170146 times.
 170146 assert(sp_result_field);
8252
1/2
✓ Branch 0 taken 170146 times.
✗ Branch 1 not taken.
 170146 set_data_type(sp_result_field->type());
8253
1/2
✓ Branch 0 taken 170146 times.
✗ Branch 1 not taken.
 170146 decimals = sp_result_field->decimals();
8254 170146 max_length = sp_result_field->field_length;
8255
1/2
✓ Branch 0 taken 170146 times.
✗ Branch 1 not taken.
 170146 collation.set(sp_result_field->charset());
8256 170146 set_nullable(true);
8257 170146 unsigned_flag = sp_result_field->is_flag_set(UNSIGNED_FLAG);
8258
8259 170146 return false;
8260 170146 }
8261
8262 236998 longlong Item_func_sp::val_int() {
8263
2/2
✓ Branch 0 taken 230 times.
✓ Branch 1 taken 236768 times.
 236998 if (execute()) return error_int();
8264
2/2
✓ Branch 0 taken 24757 times.
✓ Branch 1 taken 212011 times.
 236768 if (null_value) return 0;
8265 212011 return sp_result_field->val_int();
8266 }
8267
8268 156 double Item_func_sp::val_real() {
8269
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 152 times.
 156 if (execute()) return error_real();
8270
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 151 times.
 152 if (null_value) return 0.0;
8271 151 return sp_result_field->val_real();
8272 }
8273
8274 13 bool Item_func_sp::get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) {
8275
5/6
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 12 times.
 13 if (execute() || null_value) return true;
8276 12 return sp_result_field->get_date(ltime, fuzzydate);
8277 }
8278
8279 7 bool Item_func_sp::get_time(MYSQL_TIME *ltime) {
8280
3/6
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 7 times.
 7 if (execute() || null_value) return true;
8281 7 return sp_result_field->get_time(ltime);
8282 }
8283
8284 1227 my_decimal *Item_func_sp::val_decimal(my_decimal *dec_buf) {
8285
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1226 times.
 1227 if (execute()) return error_decimal(dec_buf);
8286
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1226 times.
 1226 if (null_value) return nullptr;
8287 1226 return sp_result_field->val_decimal(dec_buf);
8288 }
8289
8290 66834 String *Item_func_sp::val_str(String *str) {
8291 66834 StringBuffer<STRING_BUFFER_USUAL_SIZE> buf(str->charset());
8292
4/6
✓ Branch 0 taken 66834 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 66813 times.
✓ Branch 4 taken 21 times.
✗ Branch 5 not taken.
 66834 if (execute()) return error_str();
8293
2/2
✓ Branch 0 taken 124 times.
✓ Branch 1 taken 66689 times.
 66813 if (null_value) return nullptr;
8294 /*
8295 result_field will set buf pointing to internal buffer
8296 of the resul_field. Due to this it will change any time
8297 when SP is executed. In order to prevent occasional
8298 corruption of returned value, we make here a copy.
8299 */
8300
1/2
✓ Branch 0 taken 66689 times.
✗ Branch 1 not taken.
 66689 sp_result_field->val_str(&buf);
8301
1/2
✓ Branch 0 taken 66689 times.
✗ Branch 1 not taken.
 66689 str->copy(buf);
8302 66689 return str;
8303 66834 }
8304
8305 6 bool Item_func_sp::val_json(Json_wrapper *result) {
8306
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (sp_result_field->type() == MYSQL_TYPE_JSON) {
8307
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5 times.
 6 if (execute()) return true;
8308
8309
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 if (null_value) return false;
8310
8311 5 Field_json *json_value = down_cast<Field_json *>(sp_result_field);
8312 5 return json_value->val_json(result);
8313 }
8314
8315 /* purecov: begin deadcode */
8316 ✗ assert(false);
8317 my_error(ER_INVALID_CAST_TO_JSON, MYF(0));
8318 return error_json();
8319 /* purecov: end */
8320 }
8321
8322 /**
8323 @brief Execute function & store value in field.
8324 Will set null_value properly only for a successful execution.
8325 @return Function returns error status.
8326 @retval false on success.
8327 @retval true if an error occurred.
8328 */
8329
8330 305241 bool Item_func_sp::execute() {
8331
1/2
✓ Branch 0 taken 305241 times.
✗ Branch 1 not taken.
 305241 THD *thd = current_thd;
8332
8333 Internal_error_handler_holder<View_error_handler, TABLE_LIST> view_handler(
8334
1/2
✓ Branch 0 taken 305241 times.
✗ Branch 1 not taken.
 305241 thd, context->view_error_handler, context->view_error_handler_arg);
8335
8336 // Bind to an instance of the stored function:
8337
2/2
✓ Branch 0 taken 48499 times.
✓ Branch 1 taken 256742 times.
 305241 if (m_sp == nullptr) {
8338
1/2
✓ Branch 0 taken 48499 times.
✗ Branch 1 not taken.
 48499 m_sp = sp_setup_routine(thd, enum_sp_type::FUNCTION, m_name,
8339 &thd->sp_func_cache);
8340
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 48482 times.
 48499 if (m_sp == nullptr) return true;
8341
1/2
✓ Branch 0 taken 48482 times.
✗ Branch 1 not taken.
 48482 if (sp_result_field != nullptr) {
8342
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48482 times.
 48482 assert(sp_result_field->table->in_use == nullptr);
8343 48482 sp_result_field->table->in_use = thd;
8344 }
8345 }
8346
8347 /* Execute function and store the return value in the field. */
8348
8349
3/4
✓ Branch 0 taken 305224 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 240 times.
✓ Branch 3 taken 304984 times.
 305224 if (execute_impl(thd)) {
8350 240 null_value = true;
8351
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 232 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
 240 if (thd->killed) thd->send_kill_message();
8352 240 return true;
8353 }
8354
8355 /* Check that the field (the value) is not NULL. */
8356
1/2
✓ Branch 0 taken 304984 times.
✗ Branch 1 not taken.
 304984 null_value = sp_result_field->is_null();
8357
8358 304984 return false;
8359 305241 }
8360
8361 /**
8362 @brief Execute function and store the return value in the field.
8363 Will set null_value properly only for a successful execution.
8364
8365 @note This function was intended to be the concrete implementation of
8366 the interface function execute. This was never realized.
8367
8368 @return The error state.
8369 @retval false on success
8370 @retval true if an error occurred.
8371 */
8372 305224 bool Item_func_sp::execute_impl(THD *thd) {
8373 305224 bool err_status = true;
8374 305224 Sub_statement_state statement_state;
8375 305224 Security_context *save_security_ctx = thd->security_context();
8376 305224 enum enum_sp_data_access access =
8377 305224 (m_sp->m_chistics->daccess == SP_DEFAULT_ACCESS)
8378
1/2
✓ Branch 0 taken 305224 times.
✗ Branch 1 not taken.
 305224 ? SP_DEFAULT_ACCESS_MAPPING
8379 305224 : m_sp->m_chistics->daccess;
8380
8381
1/2
✓ Branch 0 taken 305224 times.
✗ Branch 1 not taken.
 305224 DBUG_TRACE;
8382
8383
2/2
✓ Branch 0 taken 153 times.
✓ Branch 1 taken 305071 times.
 305224 if (context->security_ctx) {
8384 /* Set view definer security context */
8385 153 thd->set_security_context(context->security_ctx);
8386 }
8387
3/4
✓ Branch 0 taken 305224 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 305223 times.
 305224 if (sp_check_access(thd)) goto error;
8388
8389 /*
8390 Throw an error if a non-deterministic function is called while
8391 statement-based replication (SBR) is active.
8392 */
8393
8394
4/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 89325 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 2 times.
 89333 if (!m_deterministic && !trust_function_creators &&
8395
6/8
✓ Branch 0 taken 89333 times.
✓ Branch 1 taken 215890 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 305222 times.
 394558 (access == SP_CONTAINS_SQL || access == SP_MODIFIES_SQL_DATA) &&
8396 2 (mysql_bin_log.is_open() &&
8397
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 thd->variables.binlog_format == BINLOG_FORMAT_STMT)) {
8398
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 my_error(ER_BINLOG_UNSAFE_ROUTINE, MYF(0));
8399 1 goto error;
8400 }
8401
8402 /*
8403 Disable the binlogging if this is not a SELECT statement. If this is a
8404 SELECT, leave binlogging on, so execute_function() code writes the
8405 function call into binlog.
8406 */
8407
1/2
✓ Branch 0 taken 305222 times.
✗ Branch 1 not taken.
 305222 thd->reset_sub_statement_state(&statement_state, SUB_STMT_FUNCTION);
8408
1/2
✓ Branch 0 taken 305222 times.
✗ Branch 1 not taken.
 305222 err_status = m_sp->execute_function(thd, args, arg_count, sp_result_field);
8409
1/2
✓ Branch 0 taken 305222 times.
✗ Branch 1 not taken.
 305222 thd->restore_sub_statement_state(&statement_state);
8410
8411 305224 error:
8412 305224 thd->set_security_context(save_security_ctx);
8413
8414 305224 return err_status;
8415 305224 }
8416
8417 6012 void Item_func_sp::make_field(Send_field *tmp_field) {
8418
1/2
✓ Branch 0 taken 6012 times.
✗ Branch 1 not taken.
 6012 DBUG_TRACE;
8419
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6012 times.
 6012 assert(sp_result_field);
8420
1/2
✓ Branch 0 taken 6012 times.
✗ Branch 1 not taken.
 6012 sp_result_field->make_send_field(tmp_field);
8421
1/2
✓ Branch 0 taken 6012 times.
✗ Branch 1 not taken.
 6012 if (item_name.is_set()) tmp_field->col_name = item_name.ptr();
8422 6012 }
8423
8424 286699 Item_result Item_func_sp::result_type() const {
8425
1/2
✓ Branch 0 taken 286699 times.
✗ Branch 1 not taken.
 286699 DBUG_TRACE;
8426
3/8
✓ Branch 0 taken 286699 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 286699 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 286699 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 286699 DBUG_PRINT("info", ("m_sp = %p", (void *)m_sp));
8427
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 286699 times.
 286699 assert(sp_result_field);
8428
1/2
✓ Branch 0 taken 286699 times.
✗ Branch 1 not taken.
 573398 return sp_result_field->result_type();
8429 286699 }
8430
8431 215 bool Item_func_found_rows::itemize(Parse_context *pc, Item **res) {
8432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (skip_itemize(res)) return false;
8433
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (super::itemize(pc, res)) return true;
8434 215 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
8435 215 pc->thd->lex->safe_to_cache_query = false;
8436 215 push_warning(current_thd, Sql_condition::SL_WARNING,
8437 ER_WARN_DEPRECATED_SYNTAX,
8438 215 ER_THD(current_thd, ER_WARN_DEPRECATED_FOUND_ROWS));
8439 215 return false;
8440 }
8441
8442 181 longlong Item_func_found_rows::val_int() {
8443
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 181 times.
 181 assert(fixed == 1);
8444 181 return current_thd->found_rows();
8445 }
8446
8447 98 Field *Item_func_sp::tmp_table_field(TABLE *) {
8448
1/2
✓ Branch 0 taken 98 times.
✗ Branch 1 not taken.
 98 DBUG_TRACE;
8449
8450
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 98 times.
 98 assert(sp_result_field);
8451 98 return sp_result_field;
8452 98 }
8453
8454 /**
8455 @brief Checks if requested access to function can be granted to user.
8456 If function isn't found yet, it searches function first.
8457 If function can't be found or user don't have requested access
8458 error is raised.
8459
8460 @param thd thread handler
8461
8462 @return Indication if the access was granted or not.
8463 @retval false Access is granted.
8464 @retval true Requested access can't be granted or function doesn't exists.
8465
8466 */
8467
8468 452920 bool Item_func_sp::sp_check_access(THD *thd) {
8469
1/2
✓ Branch 0 taken 452920 times.
✗ Branch 1 not taken.
 452920 DBUG_TRACE;
8470
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 452920 times.
 452920 assert(m_sp);
8471
3/4
✓ Branch 0 taken 452920 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 452919 times.
 452920 if (check_routine_access(thd, EXECUTE_ACL, m_sp->m_db.str, m_sp->m_name.str,
8472 false, false))
8473 1 return true;
8474
8475 452919 return false;
8476 452920 }
8477
8478 170261 bool Item_func_sp::fix_fields(THD *thd, Item **ref) {
8479 170261 Security_context *save_security_ctx = thd->security_context();
8480
8481
1/2
✓ Branch 0 taken 170261 times.
✗ Branch 1 not taken.
 170261 DBUG_TRACE;
8482
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 170261 times.
 170261 assert(fixed == 0);
8483
8484 /*
8485 Checking privileges to execute the function while creating view and
8486 executing the function of select.
8487 */
8488
4/4
✓ Branch 0 taken 147706 times.
✓ Branch 1 taken 22555 times.
✓ Branch 2 taken 53079 times.
✓ Branch 3 taken 117182 times.
 317967 if (!thd->lex->is_view_context_analysis() ||
8489
2/2
✓ Branch 0 taken 30524 times.
✓ Branch 1 taken 117182 times.
 147706 (thd->lex->sql_command == SQLCOM_CREATE_VIEW)) {
8490
2/2
✓ Branch 0 taken 179 times.
✓ Branch 1 taken 52900 times.
 53079 if (context->security_ctx) {
8491 /* Set view definer security context */
8492 179 thd->set_security_context(context->security_ctx);
8493 }
8494
8495 /*
8496 Check whether user has execute privilege or not
8497 */
8498
8499 Internal_error_handler_holder<View_error_handler, TABLE_LIST> view_handler(
8500
1/2
✓ Branch 0 taken 53079 times.
✗ Branch 1 not taken.
 53079 thd, context->view_error_handler, context->view_error_handler_arg);
8501
8502 106158 bool res = check_routine_access(thd, EXECUTE_ACL, m_name->m_db.str,
8503
1/2
✓ Branch 0 taken 53079 times.
✗ Branch 1 not taken.
 53079 m_name->m_name.str, false, false);
8504 53079 thd->set_security_context(save_security_ctx);
8505
8506
2/2
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 53050 times.
 53079 if (res) return res;
8507
2/2
✓ Branch 0 taken 53050 times.
✓ Branch 1 taken 29 times.
 53079 }
8508
8509 /*
8510 We must call init_result_field before Item_func::fix_fields()
8511 to make m_sp and result_field members available to resolve_type(),
8512 which is called from Item_func::fix_fields().
8513 */
8514
3/4
✓ Branch 0 taken 170232 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 81 times.
✓ Branch 3 taken 170151 times.
 170232 if (init_result_field(thd)) return true;
8515
8516 170151 sp_pcontext *sp_ctx = m_sp->get_root_parsing_context();
8517
8518
3/4
✓ Branch 0 taken 170151 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 170146 times.
 170151 if (arg_count != sp_ctx->context_var_count()) {
8519
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
 5 my_error(ER_SP_WRONG_NO_OF_ARGS, MYF(0), "FUNCTION", m_sp->m_qname.str,
8520 sp_ctx->context_var_count(), arg_count);
8521 5 return true;
8522 }
8523
8524
2/4
✓ Branch 0 taken 170146 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 170146 times.
 170146 if (Item_func::fix_fields(thd, ref)) return true;
8525
8526
2/2
✓ Branch 0 taken 177124 times.
✓ Branch 1 taken 170146 times.
 347270 for (uint i = 0; i < arg_count; i++) {
8527
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 177119 times.
 177124 if (args[0]->data_type() == MYSQL_TYPE_INVALID) {
8528
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 sp_variable *var = sp_ctx->find_variable(i);
8529
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 if (args[0]->propagate_type(
8530 thd,
8531 5 is_numeric_type(var->type)
8532
4/6
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 5 times.
 12 ? Type_properties(var->type, var->field_def.is_unsigned)
8533 2 : is_string_type(var->type)
8534 ? Type_properties(var->type, var->field_def.charset)
8535 : Type_properties(var->type)))
8536 ✗ return true;
8537 }
8538 }
8539
8540
2/2
✓ Branch 0 taken 147696 times.
✓ Branch 1 taken 22450 times.
 170146 if (thd->lex->is_view_context_analysis()) {
8541 /*
8542 Here we check privileges of the stored routine only during view
8543 creation, in order to validate the view. A runtime check is
8544 performed in Item_func_sp::execute(), and this method is not
8545 called during context analysis. Notice, that during view
8546 creation we do not infer into stored routine bodies and do not
8547 check privileges of its statements, which would probably be a
8548 good idea especially if the view has SQL SECURITY DEFINER and
8549 the used stored procedure has SQL SECURITY DEFINER.
8550 */
8551
2/4
✓ Branch 0 taken 147696 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 147696 times.
 147696 if (sp_check_access(thd)) return true;
8552 /*
8553 Try to set and restore the security context to see whether it's valid
8554 */
8555 Security_context *save_security_context;
8556
2/4
✓ Branch 0 taken 147696 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 147696 times.
 147696 if (m_sp->set_security_ctx(thd, &save_security_context)) return true;
8557
1/2
✓ Branch 0 taken 147696 times.
✗ Branch 1 not taken.
 147696 m_sp->m_security_ctx.restore_security_context(thd, save_security_context);
8558 }
8559
8560 // Cleanup immediately, thus execute() will always attach to the routine.
8561
1/2
✓ Branch 0 taken 170146 times.
✗ Branch 1 not taken.
 170146 cleanup();
8562
8563 170146 return false;
8564 170261 }
8565
8566 9919 void Item_func_sp::update_used_tables() {
8567 9919 Item_func::update_used_tables();
8568
8569 /* This is reset by Item_func::update_used_tables(). */
8570 9919 set_stored_program();
8571 9919 }
8572
8573 101 void Item_func_sp::fix_after_pullout(Query_block *parent_query_block,
8574 Query_block *removed_query_block) {
8575 101 Item_func::fix_after_pullout(parent_query_block, removed_query_block);
8576 101 }
8577
8578 /*
8579 uuid_short handling.
8580
8581 The short uuid is defined as a longlong that contains the following bytes:
8582
8583 Bytes Comment
8584 1 Server_id & 255
8585 4 Startup time of server in seconds
8586 3 Incrementor
8587
8588 This means that an uuid is guaranteed to be unique
8589 even in a replication environment if the following holds:
8590
8591 - The last byte of the server id is unique
8592 - If you between two shutdown of the server don't get more than
8593 an average of 2^24 = 16M calls to uuid_short() per second.
8594 */
8595
8596 ulonglong uuid_value;
8597
8598 12108 void uuid_short_init() {
8599 12108 uuid_value =
8600 12108 ((((ulonglong)server_id) << 56) + (((ulonglong)server_start_time) << 24));
8601 12108 }
8602
8603 77 bool Item_func_uuid_short::itemize(Parse_context *pc, Item **res) {
8604
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 77 times.
 77 if (skip_itemize(res)) return false;
8605
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 77 times.
 77 if (super::itemize(pc, res)) return true;
8606 77 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
8607 77 pc->thd->lex->safe_to_cache_query = false;
8608 77 return false;
8609 }
8610
8611 75 longlong Item_func_uuid_short::val_int() {
8612 ulonglong val;
8613 75 mysql_mutex_lock(&LOCK_uuid_generator);
8614 75 val = uuid_value++;
8615 75 mysql_mutex_unlock(&LOCK_uuid_generator);
8616 75 return (longlong)val;
8617 }
8618
8619 6729 bool Item_func_version::itemize(Parse_context *pc, Item **res) {
8620
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6729 times.
 6729 if (skip_itemize(res)) return false;
8621
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6729 times.
 6729 if (super::itemize(pc, res)) return true;
8622 6729 pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
8623 6729 return false;
8624 }
8625
8626 /**
8627 Check if schema and table are hidden by NDB engine.
8628
8629 @param thd Thread handle.
8630 @param schema_name Schema name.
8631 @param table_name Table name.
8632
8633 @retval true If schema and table are hidden by NDB.
8634 @retval false If schema and table are not hidden by NDB.
8635 */
8636
8637 26964038 static inline bool is_hidden_by_ndb(THD *thd, String *schema_name,
8638 String *table_name) {
8639
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26964038 times.
 26964038 if (!strncmp(schema_name->ptr(), "ndb", 3)) {
8640 ✗ List<LEX_STRING> list;
8641
8642 // Check if schema is of ndb and if it is hidden by it.
8643 ✗ LEX_STRING sch_name = schema_name->lex_string();
8644 ✗ list.push_back(&sch_name);
8645 ✗ ha_find_files(thd, nullptr, nullptr, nullptr, true, &list);
8646 ✗ if (list.elements == 0) {
8647 // Schema is hidden by ndb engine.
8648 ✗ return true;
8649 }
8650
8651 // Check if table is hidden by ndb.
8652 ✗ if (table_name != nullptr) {
8653 ✗ list.clear();
8654 ✗ LEX_STRING tbl_name = table_name->lex_string();
8655 ✗ list.push_back(&tbl_name);
8656 ✗ ha_find_files(thd, schema_name->ptr(), nullptr, nullptr, false, &list);
8657 ✗ if (list.elements == 0) {
8658 // Table is hidden by ndb engine.
8659 ✗ return true;
8660 }
8661 }
8662 }
8663
8664 26964038 return false;
8665 }
8666
8667 /**
8668 @brief
8669 INFORMATION_SCHEMA picks metadata from DD using system views.
8670 In order for INFORMATION_SCHEMA to skip listing database for which
8671 the user does not have rights, the following internal functions are used.
8672
8673 Syntax:
8674 int CAN_ACCCESS_DATABASE(schema_name);
8675
8676 @returns,
8677 1 - If current user has access.
8678 0 - If not.
8679 */
8680
8681 171741 longlong Item_func_can_access_database::val_int() {
8682
1/2
✓ Branch 0 taken 171741 times.
✗ Branch 1 not taken.
 171741 DBUG_TRACE;
8683
8684 // Read schema_name
8685 171741 String schema_name;
8686
1/2
✓ Branch 0 taken 171741 times.
✗ Branch 1 not taken.
 171741 String *schema_name_ptr = args[0]->val_str(&schema_name);
8687
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 171738 times.
 171741 if (schema_name_ptr == nullptr) {
8688 3 null_value = true;
8689 3 return 0;
8690 }
8691
8692 // Make sure we have safe string to access.
8693
1/2
✓ Branch 0 taken 171738 times.
✗ Branch 1 not taken.
 171738 schema_name_ptr->c_ptr_safe();
8694
8695 // Check if schema is hidden.
8696
1/2
✓ Branch 0 taken 171738 times.
✗ Branch 1 not taken.
 171738 THD *thd = current_thd;
8697
2/4
✓ Branch 0 taken 171738 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 171738 times.
 171738 if (is_hidden_by_ndb(thd, schema_name_ptr, nullptr)) return 0;
8698
8699 // Skip INFORMATION_SCHEMA database
8700
3/4
✓ Branch 0 taken 171738 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28440 times.
✓ Branch 3 taken 143298 times.
 171738 if (is_infoschema_db(schema_name_ptr->ptr())) return 1;
8701
8702 // Skip PERFORMANCE_SCHEMA database
8703
3/4
✓ Branch 0 taken 143298 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28423 times.
✓ Branch 3 taken 114875 times.
 143298 if (is_perfschema_db(schema_name_ptr->ptr())) return 1;
8704
8705
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 114875 times.
 114875 if (lower_case_table_names == 2) {
8706 /*
8707 ACL code assumes that in l-c-t-n > 0 modes schema name passed to it
8708 is in lower case.
8709 */
8710 ✗ my_casedn_str(files_charset_info, schema_name_ptr->ptr());
8711 }
8712
8713 // Check access
8714 114875 Security_context *sctx = thd->security_context();
8715
8/16
✓ Branch 0 taken 114875 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 114875 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 170 times.
✓ Branch 5 taken 114705 times.
✓ Branch 6 taken 114875 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 114875 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 45 times.
✓ Branch 11 taken 114830 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
 115045 if (!(sctx->master_access(schema_name_ptr->ptr()) &
8716 170 (DB_OP_ACLS | SHOW_DB_ACL) ||
8717
6/10
✓ Branch 0 taken 170 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 170 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 170 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 170 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 45 times.
✓ Branch 9 taken 125 times.
 170 acl_get(thd, sctx->host().str, sctx->ip().str, sctx->priv_user().str,
8718 170 schema_name_ptr->ptr(), false) ||
8719
2/4
✓ Branch 0 taken 45 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 45 times.
✗ Branch 3 not taken.
 45 !check_grant_db(thd, schema_name_ptr->ptr()))) {
8720 45 return 0;
8721 }
8722
8723 114830 return 1;
8724 171741 }
8725
8726 4966983 static bool check_table_and_trigger_access(Item **args, bool check_trigger_acl,
8727 bool *null_value) {
8728
1/2
✓ Branch 0 taken 4966983 times.
✗ Branch 1 not taken.
 4966983 DBUG_TRACE;
8729
8730 // Read schema_name, table_name
8731 4966983 String schema_name;
8732
1/2
✓ Branch 0 taken 4966983 times.
✗ Branch 1 not taken.
 4966983 String *schema_name_ptr = args[0]->val_str(&schema_name);
8733 4966983 String table_name;
8734
1/2
✓ Branch 0 taken 4966983 times.
✗ Branch 1 not taken.
 4966983 String *table_name_ptr = args[1]->val_str(&table_name);
8735
3/4
✓ Branch 0 taken 4966977 times.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4966977 times.
 4966983 if (schema_name_ptr == nullptr || table_name_ptr == nullptr) {
8736 6 *null_value = true;
8737 6 return false;
8738 }
8739
8740
1/2
✓ Branch 0 taken 4966977 times.
✗ Branch 1 not taken.
 4966977 const char *sch_name = schema_name_ptr->c_ptr_safe();
8741
1/2
✓ Branch 0 taken 4966977 times.
✗ Branch 1 not taken.
 4966977 const char *tbl_name = table_name_ptr->c_ptr_safe();
8742
8743 // Check if table is hidden.
8744
1/2
✓ Branch 0 taken 4966977 times.
✗ Branch 1 not taken.
 4966977 THD *thd = current_thd;
8745
2/4
✓ Branch 0 taken 4966977 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4966977 times.
 4966977 if (is_hidden_by_ndb(thd, schema_name_ptr, table_name_ptr)) return false;
8746
8747 // Don't show compression dictionary tables in "SHOW TABLES"
8748
2/4
✓ Branch 0 taken 4966977 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4966977 times.
✗ Branch 3 not taken.
 4966977 if (compression_dict::is_hardcoded(dd::String_type(sch_name),
8749
3/4
✓ Branch 0 taken 4966977 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 56559 times.
✓ Branch 3 taken 4910418 times.
 9933954 dd::String_type(tbl_name))) {
8750 56559 return false;
8751 }
8752
8753 // Skip INFORMATION_SCHEMA database
8754
3/4
✓ Branch 0 taken 4910418 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 25853 times.
✓ Branch 3 taken 4884565 times.
 4910418 if (is_infoschema_db(schema_name_ptr->ptr())) return true;
8755
8756
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4884565 times.
 4884565 if (lower_case_table_names == 2) {
8757 /*
8758 ACL code assumes that in l-c-t-n > 0 modes schema and table names
8759 passed to it are in lower case.
8760 */
8761 ✗ schema_name_ptr->length(
8762 ✗ my_casedn_str(files_charset_info, schema_name_ptr->ptr()));
8763 ✗ table_name_ptr->length(
8764 ✗ my_casedn_str(files_charset_info, table_name_ptr->ptr()));
8765 }
8766
8767 // Check access
8768 4884565 ulong db_access = 0;
8769
2/4
✓ Branch 0 taken 4884565 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4884565 times.
 4884565 if (check_access(thd, SELECT_ACL, schema_name_ptr->ptr(), &db_access, nullptr,
8770 false, true))
8771 ✗ return false;
8772
8773
1/2
✓ Branch 0 taken 4884565 times.
✗ Branch 1 not taken.
 4884565 TABLE_LIST table_list;
8774 4884565 table_list.db = schema_name_ptr->ptr();
8775 4884565 table_list.db_length = schema_name_ptr->length();
8776 4884565 table_list.table_name = table_name_ptr->ptr();
8777 4884565 table_list.table_name_length = table_name_ptr->length();
8778 4884565 table_list.grant.privilege = db_access;
8779
8780
2/2
✓ Branch 0 taken 4828146 times.
✓ Branch 1 taken 56419 times.
 4884565 if (check_trigger_acl == false) {
8781
2/2
✓ Branch 0 taken 4827180 times.
✓ Branch 1 taken 966 times.
 4828146 if (db_access & TABLE_OP_ACLS) return true;
8782
8783 // Check table access
8784
3/4
✓ Branch 0 taken 966 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 859 times.
✓ Branch 3 taken 107 times.
 966 if (check_grant(thd, TABLE_OP_ACLS, &table_list, true, 1, true))
8785 859 return false;
8786 } else // Trigger check.
8787 {
8788 // Check trigger access
8789
3/4
✓ Branch 0 taken 56419 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28 times.
✓ Branch 3 taken 56391 times.
 112838 if (check_trigger_acl &&
8790
3/4
✓ Branch 0 taken 56419 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28 times.
✓ Branch 3 taken 56391 times.
 56419 check_table_access(thd, TRIGGER_ACL, &table_list, false, 1, true))
8791 28 return false;
8792 }
8793
8794 56498 return true;
8795 4966983 }
8796
8797 /**
8798 @brief
8799 INFORMATION_SCHEMA picks metadata from new DD using system views.
8800 In order for INFORMATION_SCHEMA to skip listing table for which
8801 the user does not have rights, the following UDF's is used.
8802
8803 Syntax:
8804 int CAN_ACCCESS_TABLE(schema_name, table_name);
8805
8806 @returns,
8807 1 - If current user has access.
8808 0 - If not.
8809 */
8810 4910561 longlong Item_func_can_access_table::val_int() {
8811
1/2
✓ Branch 0 taken 4910561 times.
✗ Branch 1 not taken.
 4910561 DBUG_TRACE;
8812
8813
3/4
✓ Branch 0 taken 4910561 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4853140 times.
✓ Branch 3 taken 57421 times.
 4910561 if (check_table_and_trigger_access(args, false, &null_value)) return 1;
8814
8815 57421 return 0;
8816 4910561 }
8817
8818 /**
8819 @brief
8820 INFORMATION_SCHEMA picks metadata from new DD using system views.
8821 In order for INFORMATION_SCHEMA to skip listing user accpounts for which
8822 the user does not have rights, the following SQL function is used.
8823
8824 Syntax:
8825 int CAN_ACCCESS_USER(user_part, host_part);
8826
8827 @returns,
8828 1 - If current user has access.
8829 0 - If not.
8830
8831 @sa @ref acl_can_access_user
8832 */
8833 139 longlong Item_func_can_access_user::val_int() {
8834
1/2
✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
 139 DBUG_TRACE;
8835
8836
1/2
✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
 139 THD *thd = current_thd;
8837 // Read user, host
8838 139 String user_name;
8839
1/2
✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
 139 String *user_name_ptr = args[0]->val_str(&user_name);
8840 139 String host_name;
8841
1/2
✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
 139 String *host_name_ptr = args[1]->val_str(&host_name);
8842
3/4
✓ Branch 0 taken 136 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 136 times.
 139 if (host_name_ptr == nullptr || user_name_ptr == nullptr) {
8843 3 null_value = true;
8844 3 return 0;
8845 }
8846
8847 // Make sure we have safe string to access.
8848
1/2
✓ Branch 0 taken 136 times.
✗ Branch 1 not taken.
 136 host_name_ptr->c_ptr_safe();
8849
1/2
✓ Branch 0 taken 136 times.
✗ Branch 1 not taken.
 136 user_name_ptr->c_ptr_safe();
8850 136 MYSQL_LEX_STRING user_str = {const_cast<char *>(user_name_ptr->ptr()),
8851 136 user_name_ptr->length()};
8852 MYSQL_LEX_STRING
8853 136 host_str = {const_cast<char *>(host_name_ptr->ptr()),
8854 136 host_name_ptr->length()};
8855
1/2
✓ Branch 0 taken 136 times.
✗ Branch 1 not taken.
 136 LEX_USER user;
8856
2/4
✓ Branch 0 taken 136 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 136 times.
 136 if (!LEX_USER::init(&user, thd, &user_str, &host_str)) return 0;
8857
8858
3/4
✓ Branch 0 taken 136 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50 times.
✓ Branch 3 taken 86 times.
 136 return acl_can_access_user(thd, &user) ? 1 : 0;
8859 139 }
8860
8861 /**
8862 @brief
8863 INFORMATION_SCHEMA picks metadata from new DD using system views. In
8864 order for INFORMATION_SCHEMA to skip listing table for which the user
8865 does not have rights on triggers, the following UDF's is used.
8866
8867 Syntax:
8868 int CAN_ACCCESS_TRIGGER(schema_name, table_name);
8869
8870 @returns,
8871 1 - If current user has access.
8872 0 - If not.
8873 */
8874 56422 longlong Item_func_can_access_trigger::val_int() {
8875
1/2
✓ Branch 0 taken 56422 times.
✗ Branch 1 not taken.
 56422 DBUG_TRACE;
8876
8877
3/4
✓ Branch 0 taken 56422 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 56391 times.
✓ Branch 3 taken 31 times.
 56422 if (check_table_and_trigger_access(args, true, &null_value)) return 1;
8878
8879 31 return 0;
8880 56422 }
8881
8882 /**
8883 @brief
8884 INFORMATION_SCHEMA picks metadata from DD using system views. In
8885 order for INFORMATION_SCHEMA to skip listing routine for which the user
8886 does not have rights, the following UDF's is used.
8887
8888 Syntax:
8889 int CAN_ACCESS_ROUTINE(schema_name, name, type, user, definer,
8890 check_full_access);
8891
8892 @returns,
8893 1 - If current user has access.
8894 0 - If not.
8895 */
8896 3169668 longlong Item_func_can_access_routine::val_int() {
8897
1/2
✓ Branch 0 taken 3169668 times.
✗ Branch 1 not taken.
 3169668 DBUG_TRACE;
8898
8899 // Read schema_name, table_name
8900 3169668 String schema_name;
8901 3169668 String routine_name;
8902 3169668 String type;
8903 3169668 String definer;
8904
1/2
✓ Branch 0 taken 3169668 times.
✗ Branch 1 not taken.
 3169668 String *schema_name_ptr = args[0]->val_str(&schema_name);
8905
1/2
✓ Branch 0 taken 3169668 times.
✗ Branch 1 not taken.
 3169668 String *routine_name_ptr = args[1]->val_str(&routine_name);
8906
1/2
✓ Branch 0 taken 3169668 times.
✗ Branch 1 not taken.
 3169668 String *type_ptr = args[2]->val_str(&type);
8907
1/2
✓ Branch 0 taken 3169668 times.
✗ Branch 1 not taken.
 3169668 String *definer_ptr = args[3]->val_str(&definer);
8908
1/2
✓ Branch 0 taken 3169668 times.
✗ Branch 1 not taken.
 3169668 bool check_full_access = args[4]->val_int();
8909
4/6
✓ Branch 0 taken 3169665 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 3169665 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3169665 times.
✗ Branch 5 not taken.
 3169668 if (schema_name_ptr == nullptr || routine_name_ptr == nullptr ||
8910
2/4
✓ Branch 0 taken 3169665 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3169665 times.
 3169665 type_ptr == nullptr || definer_ptr == nullptr || args[4]->null_value) {
8911 3 null_value = true;
8912 3 return 0;
8913 }
8914
8915 // Make strings safe.
8916
1/2
✓ Branch 0 taken 3169665 times.
✗ Branch 1 not taken.
 3169665 schema_name_ptr->c_ptr_safe();
8917
1/2
✓ Branch 0 taken 3169665 times.
✗ Branch 1 not taken.
 3169665 routine_name_ptr->c_ptr_safe();
8918
1/2
✓ Branch 0 taken 3169665 times.
✗ Branch 1 not taken.
 3169665 type_ptr->c_ptr_safe();
8919
1/2
✓ Branch 0 taken 3169665 times.
✗ Branch 1 not taken.
 3169665 definer_ptr->c_ptr_safe();
8920
8921 3169665 bool is_procedure = (strcmp(type_ptr->ptr(), "PROCEDURE") == 0);
8922
8923 // Skip INFORMATION_SCHEMA database
8924
4/6
✓ Branch 0 taken 3169665 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3169665 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2668017 times.
✓ Branch 5 taken 501648 times.
 6339330 if (is_infoschema_db(schema_name_ptr->ptr()) ||
8925
3/4
✓ Branch 0 taken 3169665 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2668017 times.
✓ Branch 3 taken 501648 times.
 3169665 !my_strcasecmp(system_charset_info, schema_name_ptr->ptr(), "sys"))
8926 2668017 return 1;
8927
8928 /*
8929 Check if user has full access to the routine properties (i.e including
8930 stored routine code), or partial access (i.e to view its other properties).
8931 */
8932
8933 char user_name_holder[USERNAME_LENGTH + 1];
8934 501648 LEX_STRING user_name = {user_name_holder, USERNAME_LENGTH};
8935
8936 char host_name_holder[HOSTNAME_LENGTH + 1];
8937 501648 LEX_STRING host_name = {host_name_holder, HOSTNAME_LENGTH};
8938
8939
1/2
✓ Branch 0 taken 501648 times.
✗ Branch 1 not taken.
 501648 parse_user(definer_ptr->ptr(), definer_ptr->length(), user_name.str,
8940 &user_name.length, host_name.str, &host_name.length);
8941
8942
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 501648 times.
 501648 if (lower_case_table_names == 2) {
8943 /*
8944 ACL code assumes that in l-c-t-n > 0 modes schema name passed to it
8945 is in lower case.
8946 */
8947 ✗ my_casedn_str(files_charset_info, schema_name_ptr->ptr());
8948 }
8949
8950
1/2
✓ Branch 0 taken 501648 times.
✗ Branch 1 not taken.
 501648 THD *thd = current_thd;
8951
1/2
✓ Branch 0 taken 501648 times.
✗ Branch 1 not taken.
 501648 bool full_access = has_full_view_routine_access(thd, schema_name_ptr->ptr(),
8952 501648 user_name.str, host_name.str);
8953
8954
2/2
✓ Branch 0 taken 250216 times.
✓ Branch 1 taken 251432 times.
 501648 if (check_full_access) {
8955
2/2
✓ Branch 0 taken 250178 times.
✓ Branch 1 taken 38 times.
 250216 return full_access ? 1 : 0;
8956
7/8
✓ Branch 0 taken 129 times.
✓ Branch 1 taken 251303 times.
✓ Branch 2 taken 129 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 65 times.
✓ Branch 5 taken 64 times.
✓ Branch 6 taken 65 times.
✓ Branch 7 taken 251367 times.
 251561 } else if (!full_access && !has_partial_view_routine_access(
8957 129 thd, schema_name_ptr->ptr(),
8958 129 routine_name_ptr->ptr(), is_procedure)) {
8959 65 return 0;
8960 }
8961
8962 251367 return 1;
8963 3169668 }
8964
8965 /**
8966 @brief
8967 INFORMATION_SCHEMA picks metadata from DD using system views.
8968 In order for INFORMATION_SCHEMA to skip listing event for which
8969 the user does not have rights, the following internal functions are used.
8970
8971 Syntax:
8972 int CAN_ACCCESS_EVENT(schema_name);
8973
8974 @returns,
8975 1 - If current user has access.
8976 0 - If not.
8977 */
8978
8979 1070 longlong Item_func_can_access_event::val_int() {
8980
1/2
✓ Branch 0 taken 1070 times.
✗ Branch 1 not taken.
 1070 DBUG_TRACE;
8981
8982 // Read schema_name
8983 1070 String schema_name;
8984
1/2
✓ Branch 0 taken 1070 times.
✗ Branch 1 not taken.
 1070 String *schema_name_ptr = args[0]->val_str(&schema_name);
8985
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1067 times.
 1070 if (schema_name_ptr == nullptr) {
8986 3 null_value = true;
8987 3 return 0;
8988 }
8989
8990 // Make sure we have safe string to access.
8991
1/2
✓ Branch 0 taken 1067 times.
✗ Branch 1 not taken.
 1067 schema_name_ptr->c_ptr_safe();
8992
8993 // Check if schema is hidden.
8994
1/2
✓ Branch 0 taken 1067 times.
✗ Branch 1 not taken.
 1067 THD *thd = current_thd;
8995
2/4
✓ Branch 0 taken 1067 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1067 times.
 1067 if (is_hidden_by_ndb(thd, schema_name_ptr, nullptr)) return 0;
8996
8997 // Skip INFORMATION_SCHEMA database
8998
3/4
✓ Branch 0 taken 1067 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1065 times.
 1067 if (is_infoschema_db(schema_name_ptr->ptr())) return 1;
8999
9000
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1065 times.
 1065 if (lower_case_table_names == 2) {
9001 /*
9002 ACL code assumes that in l-c-t-n > 0 modes schema name passed to it
9003 is in lower case.
9004 */
9005 ✗ my_casedn_str(files_charset_info, schema_name_ptr->ptr());
9006 }
9007
9008 // Check access
9009
3/4
✓ Branch 0 taken 1065 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 1062 times.
 1065 if (check_access(thd, EVENT_ACL, schema_name_ptr->ptr(), nullptr, nullptr,
9010 false, true)) {
9011 3 return 0;
9012 }
9013
9014 1062 return 1;
9015 1070 }
9016
9017 /**
9018 @brief
9019 INFORMATION_SCHEMA picks metadata from DD using system views.
9020 In order for INFORMATION_SCHEMA to skip listing resource groups for which
9021 the user does not have rights, the following internal functions are used.
9022
9023 Syntax:
9024 int CAN_ACCCESS_RESOURCE_GROUP(resource_group_name);
9025
9026 @returns,
9027 1 - If current user has access.
9028 0 - If not.
9029 */
9030
9031 24 longlong Item_func_can_access_resource_group::val_int() {
9032
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 DBUG_TRACE;
9033
9034
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 auto mgr_ptr = resourcegroups::Resource_group_mgr::instance();
9035
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 if (!mgr_ptr->resource_group_support()) {
9036 ✗ null_value = true;
9037 ✗ return false;
9038 }
9039
9040 // Read resource group name.
9041 24 String res_grp_name;
9042
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 String *res_grp_name_ptr = args[0]->val_str(&res_grp_name);
9043
9044
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 if (res_grp_name_ptr == nullptr) {
9045 ✗ null_value = true;
9046 ✗ return false;
9047 }
9048
9049 // Make sure we have safe string to access.
9050
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 res_grp_name_ptr->c_ptr_safe();
9051
9052 24 MDL_ticket *ticket = nullptr;
9053
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 if (mgr_ptr->acquire_shared_mdl_for_resource_group(
9054
3/6
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24 times.
✗ Branch 5 not taken.
 24 current_thd, res_grp_name_ptr->c_ptr(), MDL_EXPLICIT, &ticket, false))
9055 ✗ return false;
9056
9057
3/6
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24 times.
✗ Branch 5 not taken.
 24 auto res_grp_ptr = mgr_ptr->get_resource_group(res_grp_name_ptr->c_ptr());
9058 24 longlong result = true;
9059
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 if (res_grp_ptr != nullptr) {
9060
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 Security_context *sctx = current_thd->security_context();
9061
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 14 times.
 24 if (res_grp_ptr->type() == resourcegroups::Type::SYSTEM_RESOURCE_GROUP) {
9062
8/16
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 4 times.
✓ Branch 6 taken 10 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 10 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 4 times.
✓ Branch 11 taken 6 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
 16 if (!(sctx->check_access(SUPER_ACL) ||
9063
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 sctx->has_global_grant(STRING_WITH_LEN("RESOURCE_GROUP_ADMIN"))
9064
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
 6 .first))
9065 4 result = false;
9066 } else {
9067
8/16
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 11 times.
✓ Branch 6 taken 14 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 14 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✓ Branch 11 taken 13 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
 17 if (!(sctx->check_access(SUPER_ACL) ||
9068
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 sctx->has_global_grant(STRING_WITH_LEN("RESOURCE_GROUP_ADMIN"))
9069
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 .first ||
9070
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 sctx->has_global_grant(STRING_WITH_LEN("RESOURCE_GROUP_USER"))
9071
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 .first))
9072 1 result = false;
9073 }
9074 }
9075
2/4
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
 24 mgr_ptr->release_shared_mdl_for_resource_group(current_thd, ticket);
9076
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 return res_grp_ptr != nullptr ? result : false;
9077 24 }
9078
9079 /**
9080 @brief
9081 INFORMATION_SCHEMA picks metadata from DD using system views.
9082 In order for INFORMATION_SCHEMA to skip listing column for which
9083 the user does not have rights, the following UDF's is used.
9084
9085 Syntax:
9086 int CAN_ACCCESS_COLUMN(schema_name,
9087 table_name,
9088 field_name);
9089
9090 @returns,
9091 1 - If current user has access.
9092 0 - If not.
9093 */
9094 21824259 longlong Item_func_can_access_column::val_int() {
9095
1/2
✓ Branch 0 taken 21824259 times.
✗ Branch 1 not taken.
 21824259 DBUG_TRACE;
9096
9097 // Read schema_name, table_name
9098 21824259 String schema_name;
9099
1/2
✓ Branch 0 taken 21824259 times.
✗ Branch 1 not taken.
 21824259 String *schema_name_ptr = args[0]->val_str(&schema_name);
9100 21824259 String table_name;
9101
1/2
✓ Branch 0 taken 21824259 times.
✗ Branch 1 not taken.
 21824259 String *table_name_ptr = args[1]->val_str(&table_name);
9102
3/4
✓ Branch 0 taken 21824256 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 21824256 times.
 21824259 if (schema_name_ptr == nullptr || table_name_ptr == nullptr) {
9103 3 null_value = true;
9104 3 return 0;
9105 }
9106
9107 // Make sure we have safe string to access.
9108
1/2
✓ Branch 0 taken 21824256 times.
✗ Branch 1 not taken.
 21824256 schema_name_ptr->c_ptr_safe();
9109
1/2
✓ Branch 0 taken 21824256 times.
✗ Branch 1 not taken.
 21824256 table_name_ptr->c_ptr_safe();
9110
9111 // Check if table is hidden.
9112
1/2
✓ Branch 0 taken 21824256 times.
✗ Branch 1 not taken.
 21824256 THD *thd = current_thd;
9113
2/4
✓ Branch 0 taken 21824256 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 21824256 times.
 21824256 if (is_hidden_by_ndb(thd, schema_name_ptr, table_name_ptr)) return 0;
9114
9115 // Read column_name.
9116 21824256 String column_name;
9117
1/2
✓ Branch 0 taken 21824256 times.
✗ Branch 1 not taken.
 21824256 String *column_name_ptr = args[2]->val_str(&column_name);
9118
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21824256 times.
 21824256 if (column_name_ptr == nullptr) {
9119 ✗ null_value = true;
9120 ✗ return 0;
9121 }
9122
9123 // Make sure we have safe string to access.
9124
1/2
✓ Branch 0 taken 21824256 times.
✗ Branch 1 not taken.
 21824256 column_name_ptr->c_ptr_safe();
9125
9126 // Skip INFORMATION_SCHEMA database
9127
3/4
✓ Branch 0 taken 21824256 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28089 times.
✓ Branch 3 taken 21796167 times.
 21824256 if (is_infoschema_db(schema_name_ptr->ptr())) return 1;
9128
9129 // Check access
9130
1/2
✓ Branch 0 taken 21796167 times.
✗ Branch 1 not taken.
 21796167 GRANT_INFO grant_info;
9131
9132
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21796167 times.
 21796167 if (lower_case_table_names == 2) {
9133 /*
9134 ACL code assumes that in l-c-t-n > 0 modes schema and table names
9135 passed to it are in lower case.
9136 */
9137 ✗ my_casedn_str(files_charset_info, schema_name_ptr->ptr());
9138 ✗ my_casedn_str(files_charset_info, table_name_ptr->ptr());
9139 }
9140
9141
2/4
✓ Branch 0 taken 21796167 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 21796167 times.
 21796167 if (check_access(thd, SELECT_ACL, schema_name_ptr->ptr(),
9142 &grant_info.privilege, nullptr, false, true))
9143 ✗ return 0;
9144
9145 uint col_access =
9146
1/2
✓ Branch 0 taken 21796167 times.
✗ Branch 1 not taken.
 21796167 get_column_grant(thd, &grant_info, schema_name_ptr->ptr(),
9147 21796167 table_name_ptr->ptr(), column_name_ptr->ptr()) &
9148 21796167 COL_ACLS;
9149
2/2
✓ Branch 0 taken 307 times.
✓ Branch 1 taken 21795860 times.
 21796167 if (!col_access) {
9150 307 return 0;
9151 }
9152
9153 21795860 return 1;
9154 21824259 }
9155
9156 /**
9157 @brief
9158 INFORMATION_SCHEMA picks metadata from DD using system views.
9159 In order for INFORMATION_SCHEMA to skip listing view definition
9160 for the user without rights, the following UDF's is used.
9161
9162 Syntax:
9163 int CAN_ACCESS_VIEW(schema_name, view_name, definer, options);
9164
9165 @returns,
9166 1 - If current user has access.
9167 0 - If not.
9168 */
9169 2777971 longlong Item_func_can_access_view::val_int() {
9170
1/2
✓ Branch 0 taken 2777971 times.
✗ Branch 1 not taken.
 2777971 DBUG_TRACE;
9171
9172 // Read schema_name, table_name
9173 2777971 String schema_name;
9174 2777971 String table_name;
9175 2777971 String definer;
9176 2777971 String options;
9177
1/2
✓ Branch 0 taken 2777971 times.
✗ Branch 1 not taken.
 2777971 String *schema_name_ptr = args[0]->val_str(&schema_name);
9178
1/2
✓ Branch 0 taken 2777971 times.
✗ Branch 1 not taken.
 2777971 String *table_name_ptr = args[1]->val_str(&table_name);
9179
1/2
✓ Branch 0 taken 2777971 times.
✗ Branch 1 not taken.
 2777971 String *definer_ptr = args[2]->val_str(&definer);
9180
1/2
✓ Branch 0 taken 2777971 times.
✗ Branch 1 not taken.
 2777971 String *options_ptr = args[3]->val_str(&options);
9181
4/6
✓ Branch 0 taken 2777968 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2777968 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2777968 times.
✗ Branch 5 not taken.
 2777971 if (schema_name_ptr == nullptr || table_name_ptr == nullptr ||
9182
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2777968 times.
 2777968 definer_ptr == nullptr || options_ptr == nullptr) {
9183 3 null_value = true;
9184 3 return 0;
9185 }
9186
9187 // Make strings safe.
9188
1/2
✓ Branch 0 taken 2777968 times.
✗ Branch 1 not taken.
 2777968 schema_name_ptr->c_ptr_safe();
9189
1/2
✓ Branch 0 taken 2777968 times.
✗ Branch 1 not taken.
 2777968 table_name_ptr->c_ptr_safe();
9190
1/2
✓ Branch 0 taken 2777968 times.
✗ Branch 1 not taken.
 2777968 definer_ptr->c_ptr_safe();
9191
1/2
✓ Branch 0 taken 2777968 times.
✗ Branch 1 not taken.
 2777968 options_ptr->c_ptr_safe();
9192
9193 // Skip INFORMATION_SCHEMA database
9194
4/6
✓ Branch 0 taken 2777968 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2777968 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2777714 times.
✓ Branch 5 taken 254 times.
 5555936 if (is_infoschema_db(schema_name_ptr->ptr()) ||
9195
3/4
✓ Branch 0 taken 2777968 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2777714 times.
✓ Branch 3 taken 254 times.
 2777968 !my_strcasecmp(system_charset_info, schema_name_ptr->ptr(), "sys"))
9196 2777714 return 1;
9197
9198
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 254 times.
 254 if (lower_case_table_names == 2) {
9199 /*
9200 ACL code assumes that in l-c-t-n > 0 modes schema and table names
9201 passed to it are in lower case. Although for view names lowercasing
9202 is not strictly necessary until bug#20356 is fixed we still do it
9203 to be consistent with CAN_ACCESS_TABLE().
9204 */
9205 ✗ schema_name_ptr->length(
9206 ✗ my_casedn_str(files_charset_info, schema_name_ptr->ptr()));
9207 ✗ table_name_ptr->length(
9208 ✗ my_casedn_str(files_charset_info, table_name_ptr->ptr()));
9209 }
9210
9211 // Check if view is valid. If view is invalid then push invalid view
9212 // warning.
9213 254 bool is_view_valid = true;
9214 std::unique_ptr<dd::Properties> view_options(
9215
3/6
✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 254 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 254 times.
✗ Branch 5 not taken.
 254 dd::Properties::parse_properties(options_ptr->c_ptr_safe()));
9216
9217 // Warn if the property string is corrupt.
9218
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 254 times.
 254 if (!view_options.get()) {
9219 ✗ LogErr(WARNING_LEVEL, ER_WARN_PROPERTY_STRING_PARSE_FAILED,
9220 options_ptr->c_ptr_safe());
9221 ✗ assert(false);
9222 return 0;
9223 }
9224
9225
3/6
✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 254 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 254 times.
 254 if (view_options->get("view_valid", &is_view_valid)) return 0;
9226
9227 // Show warning/error if view is invalid.
9228
1/2
✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
 254 THD *thd = current_thd;
9229
1/2
✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
 254 const String db_str(schema_name_ptr->c_ptr_safe(), system_charset_info);
9230
1/2
✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
 254 const String name_str(table_name_ptr->c_ptr_safe(), system_charset_info);
9231
4/4
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 186 times.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 243 times.
 322 if (!is_view_valid &&
9232
3/4
✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 57 times.
 68 !thd->lex->m_IS_table_stats.check_error_for_key(db_str, name_str)) {
9233 std::string err_message = push_view_warning_or_error(
9234
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
 11 current_thd, schema_name_ptr->ptr(), table_name_ptr->ptr());
9235
9236 /*
9237 Cache the error message, so that we do not show the same error multiple
9238 times.
9239 */
9240
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
 11 thd->lex->m_IS_table_stats.store_error_message(db_str, name_str, nullptr,
9241 err_message.c_str());
9242 11 }
9243
9244 //
9245 // Check if definer user/host has access.
9246 //
9247
9248 254 Security_context *sctx = thd->security_context();
9249
9250 // NOTE: this is a copy/paste from sp_head::set_definer().
9251
9252 char user_name_holder[USERNAME_LENGTH + 1];
9253 254 LEX_STRING user_name = {user_name_holder, USERNAME_LENGTH};
9254
9255 char host_name_holder[HOSTNAME_LENGTH + 1];
9256 254 LEX_STRING host_name = {host_name_holder, HOSTNAME_LENGTH};
9257
9258
1/2
✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
 254 parse_user(definer_ptr->ptr(), definer_ptr->length(), user_name.str,
9259 &user_name.length, host_name.str, &host_name.length);
9260
9261
1/2
✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
 254 std::string definer_user(user_name.str, user_name.length);
9262
1/2
✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
 254 std::string definer_host(host_name.str, host_name.length);
9263
9264
5/6
✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 222 times.
✓ Branch 3 taken 32 times.
✓ Branch 4 taken 222 times.
✓ Branch 5 taken 32 times.
 476 if (!strcmp(definer_user.c_str(), sctx->priv_user().str) &&
9265
3/6
✓ Branch 0 taken 222 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 222 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 222 times.
✗ Branch 5 not taken.
 222 !my_strcasecmp(system_charset_info, definer_host.c_str(),
9266 sctx->priv_host().str))
9267 222 return 1;
9268
9269 //
9270 // Check for ACL's
9271 //
9272
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 TABLE_LIST table_list;
9273 32 table_list.db = schema_name_ptr->ptr();
9274 32 table_list.db_length = schema_name_ptr->length();
9275 32 table_list.table_name = table_name_ptr->ptr();
9276 32 table_list.table_name_length = table_name_ptr->length();
9277
9278
3/4
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 20 times.
 32 if (!check_table_access(thd, (SHOW_VIEW_ACL | SELECT_ACL), &table_list, false,
9279 1, true))
9280 12 return 1;
9281
9282 20 return 0;
9283 2777971 }
9284
9285 /**
9286 Skip hidden tables, columns, indexes and index elements. Additionally,
9287 skip generated invisible primary key(GIPK) and key column when system
9288 variable show_gipk_in_create_table_and_information_schema is set to
9289 OFF.
9290 Do *not* skip hidden tables, columns, indexes and index elements,
9291 when SHOW EXTENDED command are run. GIPK and key column are skipped
9292 even for SHOW EXTENED command.
9293
9294 Syntax:
9295 longlong IS_VISIBLE_DD_OBJECT(type_of_hidden_table [, is_object_hidden
9296 [, object_options]])
9297
9298 @returns,
9299 1 - If dd object is visible
9300 0 - If not visible.
9301 */
9302 24249465 longlong Item_func_is_visible_dd_object::val_int() {
9303
1/2
✓ Branch 0 taken 24249465 times.
✗ Branch 1 not taken.
 24249465 DBUG_TRACE;
9304
9305
2/4
✓ Branch 0 taken 24249465 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24249465 times.
✗ Branch 3 not taken.
 24249465 assert(arg_count > 0 && arg_count <= 3);
9306
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24249465 times.
 24249465 assert(args[0]->null_value == false);
9307
9308
4/6
✓ Branch 0 taken 24249465 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 22115239 times.
✓ Branch 3 taken 2134226 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 22115239 times.
 24249465 if (args[0]->null_value || (arg_count >= 2 && args[1]->null_value)) {
9309 ✗ null_value = true;
9310 ✗ return false;
9311 }
9312
9313 24249465 null_value = false;
9314
1/2
✓ Branch 0 taken 24249465 times.
✗ Branch 1 not taken.
 24249465 THD *thd = current_thd;
9315
9316 auto table_type =
9317
1/2
✓ Branch 0 taken 24249465 times.
✗ Branch 1 not taken.
 24249465 static_cast<dd::Abstract_table::enum_hidden_type>(args[0]->val_int());
9318
9319 24249465 bool show_table = (table_type == dd::Abstract_table::HT_VISIBLE);
9320
9321 // Make I_S.TABLES show the hidden system view 'show_statistics' for
9322 // testing purpose.
9323
3/4
✓ Branch 0 taken 24249465 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 46 times.
✓ Branch 3 taken 24249419 times.
 24249465 DBUG_EXECUTE_IF("fetch_system_view_definition", { return 1; });
9324
9325
2/2
✓ Branch 0 taken 67 times.
✓ Branch 1 taken 24249352 times.
 24249419 if (thd->lex->m_extended_show)
9326 67 show_table =
9327
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 63 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 67 show_table || (table_type == dd::Abstract_table::HT_HIDDEN_DDL);
9328
9329
6/6
✓ Branch 0 taken 22115239 times.
✓ Branch 1 taken 2134180 times.
✓ Branch 2 taken 11048385 times.
✓ Branch 3 taken 11066854 times.
✓ Branch 4 taken 1226989 times.
✓ Branch 5 taken 11955576 times.
 24249419 if (arg_count == 1 || show_table == false) return (show_table ? 1 : 0);
9330
9331 // Skip generated invisible primary key and key columns.
9332
6/8
✓ Branch 0 taken 11066854 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11066854 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8877375 times.
✓ Branch 5 taken 2189479 times.
✓ Branch 6 taken 185 times.
✓ Branch 7 taken 11066669 times.
 19944229 if (arg_count == 3 && !args[2]->is_null() &&
9333
2/2
✓ Branch 0 taken 185 times.
✓ Branch 1 taken 8877190 times.
 8877375 !thd->variables.show_gipk_in_create_table_and_information_schema) {
9334 185 String options;
9335
1/2
✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
 185 String *options_ptr = args[2]->val_str(&options);
9336
9337
1/2
✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
 185 if (options_ptr != nullptr) {
9338 // Read options from properties
9339 std::unique_ptr<dd::Properties> p(
9340
3/6
✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 185 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 185 times.
✗ Branch 5 not taken.
 185 dd::Properties::parse_properties(options_ptr->c_ptr_safe()));
9341
9342
1/2
✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
 185 if (p.get()) {
9343
4/6
✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 185 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 88 times.
✓ Branch 5 taken 97 times.
 185 if (p->exists("gipk")) {
9344 88 bool gipk_value = false;
9345
2/4
✓ Branch 0 taken 88 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.
✗ Branch 3 not taken.
 88 p->get("gipk", &gipk_value);
9346
1/2
✓ Branch 0 taken 88 times.
✗ Branch 1 not taken.
 88 if (gipk_value) return 0;
9347 }
9348 } else {
9349 // Warn if the property string is corrupt.
9350 ✗ LogErr(WARNING_LEVEL, ER_WARN_PROPERTY_STRING_PARSE_FAILED,
9351 options_ptr->c_ptr_safe());
9352 ✗ assert(false);
9353 }
9354
2/2
✓ Branch 0 taken 97 times.
✓ Branch 1 taken 88 times.
 185 }
9355 /*
9356 Even if object is not a GIPK column/key we still need to check if it is
9357 marked as hidden.
9358 */
9359
2/2
✓ Branch 0 taken 97 times.
✓ Branch 1 taken 88 times.
 185 }
9360
9361 bool show_non_table_objects;
9362
2/2
✓ Branch 0 taken 55 times.
✓ Branch 1 taken 11066711 times.
 11066766 if (thd->lex->m_extended_show)
9363 55 show_non_table_objects = true;
9364 else
9365
1/2
✓ Branch 0 taken 11066711 times.
✗ Branch 1 not taken.
 11066711 show_non_table_objects = (args[1]->val_bool() == false);
9366
9367
2/2
✓ Branch 0 taken 8899207 times.
✓ Branch 1 taken 2167559 times.
 11066766 return show_non_table_objects ? 1 : 0;
9368 24249465 }
9369
9370 /**
9371 Get table statistics from dd::info_schema::get_table_statistics.
9372
9373 @param args List of parameters in following order,
9374
9375 - Schema_name
9376 - Table_name
9377 - Engine_name
9378 - se_private_id
9379 - Hidden_table
9380 - Tablespace_se_private_data
9381 - Table_se_private_data (Used if stype is AUTO_INC)
9382 - Partition name (optional argument).
9383
9384 @param arg_count Number of arguments in 'args'
9385
9386 @param stype Type of statistics that is requested
9387
9388 @param[out] null_value Marked true indicating NULL, if there is no value.
9389
9390 @returns ulonglong representing the statistics requested.
9391 */
9392
9393 465408 static ulonglong get_table_statistics(
9394 Item **args, uint arg_count, dd::info_schema::enum_table_stats_type stype,
9395 bool *null_value) {
9396
1/2
✓ Branch 0 taken 465408 times.
✗ Branch 1 not taken.
 465408 DBUG_TRACE;
9397 465408 *null_value = false;
9398
9399 // Reads arguments
9400 465408 String schema_name;
9401 465408 String table_name;
9402 465408 String engine_name;
9403 465408 String ts_se_private_data;
9404 465408 String tbl_se_private_data;
9405 465408 String partition_name;
9406 465408 String *partition_name_ptr = nullptr;
9407
1/2
✓ Branch 0 taken 465408 times.
✗ Branch 1 not taken.
 465408 String *schema_name_ptr = args[0]->val_str(&schema_name);
9408
1/2
✓ Branch 0 taken 465408 times.
✗ Branch 1 not taken.
 465408 String *table_name_ptr = args[1]->val_str(&table_name);
9409
1/2
✓ Branch 0 taken 465408 times.
✗ Branch 1 not taken.
 465408 String *engine_name_ptr = args[2]->val_str(&engine_name);
9410
1/2
✓ Branch 0 taken 465408 times.
✗ Branch 1 not taken.
 465408 bool skip_hidden_table = args[4]->val_int();
9411
1/2
✓ Branch 0 taken 465408 times.
✗ Branch 1 not taken.
 465408 String *ts_se_private_data_ptr = args[5]->val_str(&ts_se_private_data);
9412
1/2
✓ Branch 0 taken 465408 times.
✗ Branch 1 not taken.
 465408 ulonglong stat_data = args[6]->val_uint();
9413
1/2
✓ Branch 0 taken 465408 times.
✗ Branch 1 not taken.
 465408 ulonglong cached_timestamp = args[7]->val_uint();
9414
9415 465408 String *tbl_se_private_data_ptr = nullptr;
9416
9417 /*
9418 The same native function used by I_S.TABLES is used by I_S.PARTITIONS.
9419 We invoke native function with partition name only with I_S.PARTITIONS
9420 as a last argument. So, we check for argument count below, before
9421 reading partition name.
9422 */
9423
2/2
✓ Branch 0 taken 57406 times.
✓ Branch 1 taken 408002 times.
 465408 if (stype == dd::info_schema::enum_table_stats_type::AUTO_INCREMENT) {
9424
1/2
✓ Branch 0 taken 57406 times.
✗ Branch 1 not taken.
 57406 tbl_se_private_data_ptr = args[8]->val_str(&tbl_se_private_data);
9425
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 57406 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 57406 if (arg_count == 10) partition_name_ptr = args[9]->val_str(&partition_name);
9426
2/2
✓ Branch 0 taken 6658 times.
✓ Branch 1 taken 401344 times.
 408002 } else if (arg_count == 9)
9427
1/2
✓ Branch 0 taken 6658 times.
✗ Branch 1 not taken.
 6658 partition_name_ptr = args[8]->val_str(&partition_name);
9428
9429
4/6
✓ Branch 0 taken 465384 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 465384 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 465384 times.
✗ Branch 5 not taken.
 465408 if (schema_name_ptr == nullptr || table_name_ptr == nullptr ||
9430
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 465368 times.
 465384 engine_name_ptr == nullptr || skip_hidden_table) {
9431 40 *null_value = true;
9432 40 return 0;
9433 }
9434
9435 // Make sure we have safe string to access.
9436
1/2
✓ Branch 0 taken 465368 times.
✗ Branch 1 not taken.
 465368 schema_name_ptr->c_ptr_safe();
9437
1/2
✓ Branch 0 taken 465368 times.
✗ Branch 1 not taken.
 465368 table_name_ptr->c_ptr_safe();
9438
1/2
✓ Branch 0 taken 465368 times.
✗ Branch 1 not taken.
 465368 engine_name_ptr->c_ptr_safe();
9439
9440 // Do not read dynamic stats for I_S tables.
9441
3/4
✓ Branch 0 taken 465368 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 155224 times.
✓ Branch 3 taken 310144 times.
 465368 if (is_infoschema_db(schema_name_ptr->ptr())) return 0;
9442
9443 // Read the statistic value from cache.
9444
1/2
✓ Branch 0 taken 310144 times.
✗ Branch 1 not taken.
 310144 THD *thd = current_thd;
9445
1/2
✓ Branch 0 taken 310144 times.
✗ Branch 1 not taken.
 310144 dd::Object_id se_private_id = (dd::Object_id)args[3]->val_uint();
9446
7/8
✓ Branch 0 taken 1080 times.
✓ Branch 1 taken 309064 times.
✓ Branch 2 taken 68592 times.
✓ Branch 3 taken 241552 times.
✓ Branch 4 taken 6644 times.
✓ Branch 5 taken 303500 times.
✓ Branch 6 taken 310144 times.
✗ Branch 7 not taken.
 386460 ulonglong result = thd->lex->m_IS_table_stats.read_stat(
9447 thd, *schema_name_ptr, *table_name_ptr, *engine_name_ptr,
9448
1/2
✓ Branch 0 taken 6644 times.
✗ Branch 1 not taken.
 6644 (partition_name_ptr ? partition_name_ptr->c_ptr_safe() : nullptr),
9449 se_private_id,
9450
1/2
✓ Branch 0 taken 68592 times.
✗ Branch 1 not taken.
 68592 (ts_se_private_data_ptr ? ts_se_private_data_ptr->c_ptr_safe() : nullptr),
9451
1/2
✓ Branch 0 taken 1080 times.
✗ Branch 1 not taken.
 1080 (tbl_se_private_data_ptr ? tbl_se_private_data_ptr->c_ptr_safe()
9452 : nullptr),
9453 stat_data, cached_timestamp, stype);
9454
9455 310144 return result;
9456 465408 }
9457
9458 58651 longlong Item_func_internal_table_rows::val_int() {
9459
1/2
✓ Branch 0 taken 58651 times.
✗ Branch 1 not taken.
 58651 DBUG_TRACE;
9460
9461
1/2
✓ Branch 0 taken 58651 times.
✗ Branch 1 not taken.
 58651 ulonglong result = get_table_statistics(
9462 args, arg_count, dd::info_schema::enum_table_stats_type::TABLE_ROWS,
9463 &null_value);
9464
9465
4/4
✓ Branch 0 taken 58648 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 58646 times.
 58651 if (null_value == false && result == (ulonglong)-1) null_value = true;
9466
9467 58651 return result;
9468 58651 }
9469
9470 58023 longlong Item_func_internal_avg_row_length::val_int() {
9471
1/2
✓ Branch 0 taken 58023 times.
✗ Branch 1 not taken.
 58023 DBUG_TRACE;
9472
9473
1/2
✓ Branch 0 taken 58023 times.
✗ Branch 1 not taken.
 58023 ulonglong result = get_table_statistics(
9474 args, arg_count,
9475 dd::info_schema::enum_table_stats_type::TABLE_AVG_ROW_LENGTH,
9476 &null_value);
9477 58023 return result;
9478 58023 }
9479
9480 58625 longlong Item_func_internal_data_length::val_int() {
9481
1/2
✓ Branch 0 taken 58625 times.
✗ Branch 1 not taken.
 58625 DBUG_TRACE;
9482
9483
1/2
✓ Branch 0 taken 58625 times.
✗ Branch 1 not taken.
 58625 ulonglong result = get_table_statistics(
9484 args, arg_count, dd::info_schema::enum_table_stats_type::DATA_LENGTH,
9485 &null_value);
9486 58625 return result;
9487 58625 }
9488
9489 58025 longlong Item_func_internal_max_data_length::val_int() {
9490
1/2
✓ Branch 0 taken 58025 times.
✗ Branch 1 not taken.
 58025 DBUG_TRACE;
9491
9492
1/2
✓ Branch 0 taken 58025 times.
✗ Branch 1 not taken.
 58025 ulonglong result = get_table_statistics(
9493 args, arg_count, dd::info_schema::enum_table_stats_type::MAX_DATA_LENGTH,
9494 &null_value);
9495 58025 return result;
9496 58025 }
9497
9498 58638 longlong Item_func_internal_index_length::val_int() {
9499
1/2
✓ Branch 0 taken 58638 times.
✗ Branch 1 not taken.
 58638 DBUG_TRACE;
9500
9501
1/2
✓ Branch 0 taken 58638 times.
✗ Branch 1 not taken.
 58638 ulonglong result = get_table_statistics(
9502 args, arg_count, dd::info_schema::enum_table_stats_type::INDEX_LENGTH,
9503 &null_value);
9504 58638 return result;
9505 58638 }
9506
9507 58020 longlong Item_func_internal_data_free::val_int() {
9508
1/2
✓ Branch 0 taken 58020 times.
✗ Branch 1 not taken.
 58020 DBUG_TRACE;
9509
9510
1/2
✓ Branch 0 taken 58020 times.
✗ Branch 1 not taken.
 58020 ulonglong result = get_table_statistics(
9511 args, arg_count, dd::info_schema::enum_table_stats_type::DATA_FREE,
9512 &null_value);
9513
9514
3/4
✓ Branch 0 taken 58017 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 58017 times.
 58020 if (null_value == false && result == (ulonglong)-1) null_value = true;
9515
9516 58020 return result;
9517 58020 }
9518
9519 57406 longlong Item_func_internal_auto_increment::val_int() {
9520
1/2
✓ Branch 0 taken 57406 times.
✗ Branch 1 not taken.
 57406 DBUG_TRACE;
9521
9522
1/2
✓ Branch 0 taken 57406 times.
✗ Branch 1 not taken.
 57406 ulonglong result = get_table_statistics(
9523 args, arg_count, dd::info_schema::enum_table_stats_type::AUTO_INCREMENT,
9524 &null_value);
9525
9526
4/4
✓ Branch 0 taken 57387 times.
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 55597 times.
✓ Branch 3 taken 1790 times.
 57406 if (null_value == false && result < (ulonglong)1) null_value = true;
9527
9528 57406 return result;
9529 57406 }
9530
9531 58020 longlong Item_func_internal_checksum::val_int() {
9532
1/2
✓ Branch 0 taken 58020 times.
✗ Branch 1 not taken.
 58020 DBUG_TRACE;
9533
9534
1/2
✓ Branch 0 taken 58020 times.
✗ Branch 1 not taken.
 58020 ulonglong result = get_table_statistics(
9535 args, arg_count, dd::info_schema::enum_table_stats_type::CHECKSUM,
9536 &null_value);
9537
9538
4/4
✓ Branch 0 taken 58017 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 58011 times.
✓ Branch 3 taken 6 times.
 58020 if (null_value == false && result == 0) null_value = true;
9539
9540 58020 return result;
9541 58020 }
9542
9543 /**
9544 @brief
9545 INFORMATION_SCHEMA picks metadata from DD using system views.
9546 INFORMATION_SCHEMA.STATISTICS.COMMENT is used to indicate if the indexes are
9547 disabled by ALTER TABLE ... DISABLE KEYS. This property of table is stored
9548 in mysql.tables.options as 'keys_disabled=0/1/'. This internal function
9549 returns value of option 'keys_disabled' for a given table.
9550
9551 Syntax:
9552 int INTERNAL_KEYS_DISABLED(table_options);
9553
9554 @returns,
9555 1 - If keys are disabled.
9556 0 - If not.
9557 */
9558 1577 longlong Item_func_internal_keys_disabled::val_int() {
9559
1/2
✓ Branch 0 taken 1577 times.
✗ Branch 1 not taken.
 1577 DBUG_TRACE;
9560
9561 // Read options.
9562 1577 String options;
9563
1/2
✓ Branch 0 taken 1577 times.
✗ Branch 1 not taken.
 1577 String *options_ptr = args[0]->val_str(&options);
9564
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1574 times.
 1577 if (options_ptr == nullptr) return 0;
9565
9566 // Read table option from properties
9567 std::unique_ptr<dd::Properties> p(
9568
3/6
✓ Branch 0 taken 1574 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1574 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1574 times.
✗ Branch 5 not taken.
 1574 dd::Properties::parse_properties(options_ptr->c_ptr_safe()));
9569
9570 // Warn if the property string is corrupt.
9571
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1574 times.
 1574 if (!p.get()) {
9572 ✗ LogErr(WARNING_LEVEL, ER_WARN_PROPERTY_STRING_PARSE_FAILED,
9573 options_ptr->c_ptr_safe());
9574 ✗ assert(false);
9575 return 0;
9576 }
9577
9578 // Read keys_disabled sub type.
9579 1574 uint keys_disabled = 0;
9580
2/4
✓ Branch 0 taken 1574 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1574 times.
✗ Branch 3 not taken.
 1574 p->get("keys_disabled", &keys_disabled);
9581
9582 1574 return keys_disabled;
9583 1577 }
9584
9585 /**
9586 @brief
9587 INFORMATION_SCHEMA picks metadata from DD using system views.
9588 INFORMATION_SCHEMA.STATISTICS.CARDINALITY reads data from SE.
9589
9590 Syntax:
9591 int INTERNAL_INDEX_COLUMN_CARDINALITY(
9592 schema_name,
9593 table_name,
9594 index_name,
9595 column_name,
9596 index_ordinal_position,
9597 column_ordinal_position,
9598 engine,
9599 se_private_id,
9600 is_hidden,
9601 stat_cardinality,
9602 cached_timestamp);
9603
9604 @returns Cardinatily. Or sets null_value to true if cardinality is -1.
9605 */
9606 4737 longlong Item_func_internal_index_column_cardinality::val_int() {
9607
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 DBUG_TRACE;
9608 4737 null_value = false;
9609
9610 // Read arguments
9611 4737 String schema_name;
9612 4737 String table_name;
9613 4737 String index_name;
9614 4737 String column_name;
9615 4737 String engine_name;
9616
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 String *schema_name_ptr = args[0]->val_str(&schema_name);
9617
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 String *table_name_ptr = args[1]->val_str(&table_name);
9618
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 String *index_name_ptr = args[2]->val_str(&index_name);
9619
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 String *column_name_ptr = args[3]->val_str(&column_name);
9620
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 uint index_ordinal_position = args[4]->val_uint();
9621
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 uint column_ordinal_position = args[5]->val_uint();
9622
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 String *engine_name_ptr = args[6]->val_str(&engine_name);
9623
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 dd::Object_id se_private_id = (dd::Object_id)args[7]->val_uint();
9624
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 bool hidden_index = args[8]->val_int();
9625
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 ulonglong stat_cardinality = args[9]->val_uint();
9626
1/2
✓ Branch 0 taken 4737 times.
✗ Branch 1 not taken.
 4737 ulonglong cached_timestamp = args[10]->val_uint();
9627
9628 // stat_cardinality and cached_timestamp from mysql.index_stats can be null
9629 // when stat is fetched for 1st time without executing ANALYZE command.
9630
4/6
✓ Branch 0 taken 4734 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 4734 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4734 times.
✗ Branch 5 not taken.
 4737 if (schema_name_ptr == nullptr || table_name_ptr == nullptr ||
9631
2/4
✓ Branch 0 taken 4734 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4734 times.
✗ Branch 3 not taken.
 4734 index_name_ptr == nullptr || engine_name_ptr == nullptr ||
9632
1/2
✓ Branch 0 taken 4734 times.
✗ Branch 1 not taken.
 4734 column_name_ptr == nullptr || args[4]->null_value ||
9633
4/6
✓ Branch 0 taken 4734 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4734 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10 times.
✓ Branch 5 taken 4724 times.
 4734 args[5]->null_value || args[8]->null_value || hidden_index) {
9634 13 null_value = true;
9635 13 return 0;
9636 }
9637
9638 // Make sure we have safe string to access.
9639
1/2
✓ Branch 0 taken 4724 times.
✗ Branch 1 not taken.
 4724 schema_name_ptr->c_ptr_safe();
9640
1/2
✓ Branch 0 taken 4724 times.
✗ Branch 1 not taken.
 4724 table_name_ptr->c_ptr_safe();
9641
1/2
✓ Branch 0 taken 4724 times.
✗ Branch 1 not taken.
 4724 index_name_ptr->c_ptr_safe();
9642
1/2
✓ Branch 0 taken 4724 times.
✗ Branch 1 not taken.
 4724 column_name_ptr->c_ptr_safe();
9643
1/2
✓ Branch 0 taken 4724 times.
✗ Branch 1 not taken.
 4724 engine_name_ptr->c_ptr_safe();
9644
9645 4724 ulonglong result = 0;
9646
1/2
✓ Branch 0 taken 4724 times.
✗ Branch 1 not taken.
 4724 THD *thd = current_thd;
9647
1/2
✓ Branch 0 taken 4724 times.
✗ Branch 1 not taken.
 4724 result = thd->lex->m_IS_table_stats.read_stat(
9648 thd, *schema_name_ptr, *table_name_ptr, *index_name_ptr, nullptr,
9649 *column_name_ptr, index_ordinal_position - 1, column_ordinal_position - 1,
9650 *engine_name_ptr, se_private_id, nullptr, nullptr, stat_cardinality,
9651 cached_timestamp,
9652 dd::info_schema::enum_table_stats_type::INDEX_COLUMN_CARDINALITY);
9653
9654
2/2
✓ Branch 0 taken 2118 times.
✓ Branch 1 taken 2606 times.
 4724 if (result == (ulonglong)-1) null_value = true;
9655
9656 4724 return result;
9657 4737 }
9658
9659 /**
9660 Retrieve tablespace statistics from SE
9661
9662 @param thd The current thread.
9663
9664 @param args List of parameters in following order,
9665
9666 - Tablespace_name
9667 - Engine_name
9668 - Tablespace_se_private_data
9669
9670 @param[out] null_value Marked true indicating NULL, if there is no value.
9671 */
9672
9673 550913 void retrieve_tablespace_statistics(THD *thd, Item **args, bool *null_value) {
9674
1/2
✓ Branch 0 taken 550913 times.
✗ Branch 1 not taken.
 550913 DBUG_TRACE;
9675 550913 *null_value = false;
9676
9677 // Reads arguments
9678 550913 String tablespace_name;
9679
1/2
✓ Branch 0 taken 550913 times.
✗ Branch 1 not taken.
 550913 String *tablespace_name_ptr = args[0]->val_str(&tablespace_name);
9680 550913 String file_name;
9681
1/2
✓ Branch 0 taken 550913 times.
✗ Branch 1 not taken.
 550913 String *file_name_ptr = args[1]->val_str(&file_name);
9682 550913 String engine_name;
9683
1/2
✓ Branch 0 taken 550913 times.
✗ Branch 1 not taken.
 550913 String *engine_name_ptr = args[2]->val_str(&engine_name);
9684 550913 String ts_se_private_data;
9685
1/2
✓ Branch 0 taken 550913 times.
✗ Branch 1 not taken.
 550913 String *ts_se_private_data_ptr = args[3]->val_str(&ts_se_private_data);
9686
9687
4/6
✓ Branch 0 taken 550883 times.
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 550883 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 550883 times.
 550913 if (tablespace_name_ptr == nullptr || file_name_ptr == nullptr ||
9688 engine_name_ptr == nullptr) {
9689 30 *null_value = true;
9690 30 return;
9691 }
9692
9693 // Make sure we have safe string to access.
9694
1/2
✓ Branch 0 taken 550883 times.
✗ Branch 1 not taken.
 550883 tablespace_name_ptr->c_ptr_safe();
9695
1/2
✓ Branch 0 taken 550883 times.
✗ Branch 1 not taken.
 550883 file_name_ptr->c_ptr_safe();
9696
1/2
✓ Branch 0 taken 550883 times.
✗ Branch 1 not taken.
 550883 engine_name_ptr->c_ptr_safe();
9697
9698 // Read the statistic value from cache.
9699
4/6
✓ Branch 0 taken 550883 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 550883 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 332 times.
✓ Branch 5 taken 550551 times.
 1101766 if (thd->lex->m_IS_tablespace_stats.read_stat(
9700 thd, *tablespace_name_ptr, *file_name_ptr, *engine_name_ptr,
9701
1/2
✓ Branch 0 taken 550883 times.
✗ Branch 1 not taken.
 550883 (ts_se_private_data_ptr ? ts_se_private_data_ptr->c_ptr_safe()
9702 : nullptr)))
9703 332 *null_value = true;
9704
10/10
✓ Branch 0 taken 550883 times.
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 550883 times.
✓ Branch 3 taken 30 times.
✓ Branch 4 taken 550883 times.
✓ Branch 5 taken 30 times.
✓ Branch 6 taken 550883 times.
✓ Branch 7 taken 30 times.
✓ Branch 8 taken 550883 times.
✓ Branch 9 taken 30 times.
 551033 }
9705
9706 18100 longlong Item_func_internal_tablespace_id::val_int() {
9707
1/2
✓ Branch 0 taken 18100 times.
✗ Branch 1 not taken.
 18100 DBUG_TRACE;
9708 18100 ulonglong result = -1;
9709
9710
1/2
✓ Branch 0 taken 18100 times.
✗ Branch 1 not taken.
 18100 THD *thd = current_thd;
9711
1/2
✓ Branch 0 taken 18100 times.
✗ Branch 1 not taken.
 18100 retrieve_tablespace_statistics(thd, args, &null_value);
9712
2/2
✓ Branch 0 taken 17766 times.
✓ Branch 1 taken 334 times.
 18100 if (null_value == false) {
9713
1/2
✓ Branch 0 taken 17766 times.
✗ Branch 1 not taken.
 17766 thd->lex->m_IS_tablespace_stats.get_stat(
9714 dd::info_schema::enum_tablespace_stats_type::TS_ID, &result);
9715 17766 return result;
9716 }
9717
9718 334 return result;
9719 18100 }
9720
9721 2 longlong Item_func_internal_tablespace_logfile_group_number::val_int() {
9722
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 DBUG_TRACE;
9723 2 ulonglong result = -1;
9724
9725
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 THD *thd = current_thd;
9726
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 retrieve_tablespace_statistics(thd, args, &null_value);
9727
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (null_value == false) {
9728
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 thd->lex->m_IS_tablespace_stats.get_stat(
9729 dd::info_schema::enum_tablespace_stats_type::TS_LOGFILE_GROUP_NUMBER,
9730 &result);
9731
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (result == (ulonglong)-1) null_value = true;
9732
9733 2 return result;
9734 }
9735
9736 ✗ return result;
9737 2 }
9738
9739 29 longlong Item_func_internal_tablespace_free_extents::val_int() {
9740
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 DBUG_TRACE;
9741 29 ulonglong result = -1;
9742
9743
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 THD *thd = current_thd;
9744
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 retrieve_tablespace_statistics(thd, args, &null_value);
9745
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 3 times.
 29 if (null_value == false) {
9746
1/2
✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
 26 thd->lex->m_IS_tablespace_stats.get_stat(
9747 dd::info_schema::enum_tablespace_stats_type::TS_FREE_EXTENTS, &result);
9748 26 return result;
9749 }
9750
9751 3 return result;
9752 29 }
9753
9754 29 longlong Item_func_internal_tablespace_total_extents::val_int() {
9755
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 DBUG_TRACE;
9756 29 ulonglong result = -1;
9757
9758
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 THD *thd = current_thd;
9759
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 retrieve_tablespace_statistics(thd, args, &null_value);
9760
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 3 times.
 29 if (null_value == false) {
9761
1/2
✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
 26 thd->lex->m_IS_tablespace_stats.get_stat(
9762 dd::info_schema::enum_tablespace_stats_type::TS_TOTAL_EXTENTS, &result);
9763 26 return result;
9764 }
9765
9766 3 return result;
9767 29 }
9768
9769 45 longlong Item_func_internal_tablespace_extent_size::val_int() {
9770
1/2
✓ Branch 0 taken 45 times.
✗ Branch 1 not taken.
 45 DBUG_TRACE;
9771 45 ulonglong result = -1;
9772
9773
1/2
✓ Branch 0 taken 45 times.
✗ Branch 1 not taken.
 45 THD *thd = current_thd;
9774
1/2
✓ Branch 0 taken 45 times.
✗ Branch 1 not taken.
 45 retrieve_tablespace_statistics(thd, args, &null_value);
9775
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 3 times.
 45 if (null_value == false) {
9776
1/2
✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
 42 thd->lex->m_IS_tablespace_stats.get_stat(
9777 dd::info_schema::enum_tablespace_stats_type::TS_EXTENT_SIZE, &result);
9778 42 return result;
9779 }
9780
9781 3 return result;
9782 45 }
9783
9784 32 longlong Item_func_internal_tablespace_initial_size::val_int() {
9785
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 DBUG_TRACE;
9786 32 ulonglong result = -1;
9787
9788
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 THD *thd = current_thd;
9789
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 retrieve_tablespace_statistics(thd, args, &null_value);
9790
2/2
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 3 times.
 32 if (null_value == false) {
9791
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 thd->lex->m_IS_tablespace_stats.get_stat(
9792 dd::info_schema::enum_tablespace_stats_type::TS_INITIAL_SIZE, &result);
9793 29 return result;
9794 }
9795
9796 3 return result;
9797 32 }
9798
9799 45 longlong Item_func_internal_tablespace_maximum_size::val_int() {
9800
1/2
✓ Branch 0 taken 45 times.
✗ Branch 1 not taken.
 45 DBUG_TRACE;
9801 45 ulonglong result = -1;
9802
9803
1/2
✓ Branch 0 taken 45 times.
✗ Branch 1 not taken.
 45 THD *thd = current_thd;
9804
1/2
✓ Branch 0 taken 45 times.
✗ Branch 1 not taken.
 45 retrieve_tablespace_statistics(thd, args, &null_value);
9805
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 3 times.
 45 if (null_value == false) {
9806
1/2
✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
 42 thd->lex->m_IS_tablespace_stats.get_stat(
9807 dd::info_schema::enum_tablespace_stats_type::TS_MAXIMUM_SIZE, &result);
9808
2/2
✓ Branch 0 taken 41 times.
✓ Branch 1 taken 1 times.
 42 if (result == (ulonglong)-1) null_value = true;
9809
9810 42 return result;
9811 }
9812
9813 3 return result;
9814 45 }
9815
9816 35 longlong Item_func_internal_tablespace_autoextend_size::val_int() {
9817
1/2
✓ Branch 0 taken 35 times.
✗ Branch 1 not taken.
 35 DBUG_TRACE;
9818 35 ulonglong result = -1;
9819
9820
1/2
✓ Branch 0 taken 35 times.
✗ Branch 1 not taken.
 35 THD *thd = current_thd;
9821
1/2
✓ Branch 0 taken 35 times.
✗ Branch 1 not taken.
 35 retrieve_tablespace_statistics(thd, args, &null_value);
9822
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 3 times.
 35 if (null_value == false) {
9823
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 thd->lex->m_IS_tablespace_stats.get_stat(
9824 dd::info_schema::enum_tablespace_stats_type::TS_AUTOEXTEND_SIZE,
9825 &result);
9826 32 return result;
9827 }
9828
9829 3 return result;
9830 35 }
9831
9832 2 longlong Item_func_internal_tablespace_version::val_int() {
9833
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 DBUG_TRACE;
9834 2 ulonglong result = -1;
9835
9836
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 THD *thd = current_thd;
9837
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 retrieve_tablespace_statistics(thd, args, &null_value);
9838
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (null_value == false) {
9839
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 thd->lex->m_IS_tablespace_stats.get_stat(
9840 dd::info_schema::enum_tablespace_stats_type::TS_VERSION, &result);
9841
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (result == (ulonglong)-1) null_value = true;
9842
9843 2 return result;
9844 }
9845
9846 ✗ return result;
9847 2 }
9848
9849 29 longlong Item_func_internal_tablespace_data_free::val_int() {
9850
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 DBUG_TRACE;
9851 29 ulonglong result = -1;
9852
9853
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 THD *thd = current_thd;
9854
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 retrieve_tablespace_statistics(thd, args, &null_value);
9855
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 3 times.
 29 if (null_value == false) {
9856
1/2
✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
 26 thd->lex->m_IS_tablespace_stats.get_stat(
9857 dd::info_schema::enum_tablespace_stats_type::TS_DATA_FREE, &result);
9858 26 return result;
9859 }
9860
9861 3 return result;
9862 29 }
9863
9864 6729 Item_func_version::Item_func_version(const POS &pos)
9865 13458 : Item_static_string_func(pos, NAME_STRING("version()"), server_version,
9866 strlen(server_version), system_charset_info,
9867
1/2
✓ Branch 0 taken 6729 times.
✗ Branch 1 not taken.
 6729 DERIVATION_SYSCONST) {}
9868
9869 /*
9870 Syntax:
9871 string get_dd_char_length()
9872 */
9873 19871160 longlong Item_func_internal_dd_char_length::val_int() {
9874
1/2
✓ Branch 0 taken 19871160 times.
✗ Branch 1 not taken.
 19871160 DBUG_TRACE;
9875 19871160 null_value = false;
9876
9877
1/2
✓ Branch 0 taken 19871160 times.
✗ Branch 1 not taken.
 19871160 dd::enum_column_types col_type = (dd::enum_column_types)args[0]->val_int();
9878
1/2
✓ Branch 0 taken 19871160 times.
✗ Branch 1 not taken.
 19871160 uint field_length = args[1]->val_int();
9879 19871160 String cs_name;
9880
1/2
✓ Branch 0 taken 19871160 times.
✗ Branch 1 not taken.
 19871160 String *cs_name_ptr = args[2]->val_str(&cs_name);
9881
1/2
✓ Branch 0 taken 19871160 times.
✗ Branch 1 not taken.
 19871160 uint flag = args[3]->val_int();
9882
9883 // Stop if we found a NULL argument.
9884
4/6
✓ Branch 0 taken 17926609 times.
✓ Branch 1 taken 1944551 times.
✓ Branch 2 taken 17926609 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 17926609 times.
✗ Branch 5 not taken.
 19871160 if (args[0]->null_value || args[1]->null_value || cs_name_ptr == nullptr ||
9885
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17926609 times.
 17926609 args[3]->null_value) {
9886 1944551 null_value = true;
9887 1944551 return 0;
9888 }
9889
9890 // Read character set.
9891
2/4
✓ Branch 0 taken 17926609 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17926609 times.
✗ Branch 3 not taken.
 17926609 CHARSET_INFO *cs = get_charset_by_name(cs_name_ptr->c_ptr_safe(), MYF(0));
9892
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17926609 times.
 17926609 if (!cs) {
9893 ✗ null_value = true;
9894 ✗ return 0;
9895 }
9896
9897 // Check data types for getting info
9898
1/2
✓ Branch 0 taken 17926609 times.
✗ Branch 1 not taken.
 17926609 enum_field_types field_type = dd_get_old_field_type(col_type);
9899 17926609 bool blob_flag = is_blob(field_type);
9900
6/6
✓ Branch 0 taken 15200547 times.
✓ Branch 1 taken 2726062 times.
✓ Branch 2 taken 11530265 times.
✓ Branch 3 taken 3670282 times.
✓ Branch 4 taken 11307523 times.
✓ Branch 5 taken 222742 times.
 17926609 if (!blob_flag && field_type != MYSQL_TYPE_ENUM &&
9901
2/2
✓ Branch 0 taken 9557074 times.
✓ Branch 1 taken 1750449 times.
 11307523 field_type != MYSQL_TYPE_SET &&
9902
2/2
✓ Branch 0 taken 5994956 times.
✓ Branch 1 taken 3562118 times.
 9557074 field_type != MYSQL_TYPE_VARCHAR && // For varbinary type
9903 field_type != MYSQL_TYPE_STRING) // For binary type
9904 {
9905 5994956 null_value = true;
9906 5994956 return 0;
9907 }
9908
9909
2/4
✓ Branch 0 taken 11931653 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11931653 times.
✗ Branch 3 not taken.
 23863306 std::ostringstream oss("");
9910
5/6
✓ Branch 0 taken 2335060 times.
✓ Branch 1 taken 140 times.
✓ Branch 2 taken 222598 times.
✓ Branch 3 taken 168264 times.
✓ Branch 4 taken 9205591 times.
✗ Branch 5 not taken.
 11931653 switch (field_type) {
9911 2335060 case MYSQL_TYPE_BLOB:
9912 2335060 field_length = 65535;
9913 2335060 break;
9914 140 case MYSQL_TYPE_TINY_BLOB:
9915 140 field_length = 255;
9916 140 break;
9917 222598 case MYSQL_TYPE_MEDIUM_BLOB:
9918 222598 field_length = 16777215;
9919 222598 break;
9920 168264 case MYSQL_TYPE_LONG_BLOB:
9921 168264 field_length = 4294967295;
9922 168264 break;
9923 9205591 case MYSQL_TYPE_ENUM:
9924 case MYSQL_TYPE_SET:
9925 case MYSQL_TYPE_VAR_STRING:
9926 case MYSQL_TYPE_VARCHAR:
9927 case MYSQL_TYPE_STRING:
9928 9205591 break;
9929 ✗ default:
9930 ✗ break;
9931 }
9932
9933
4/4
✓ Branch 0 taken 5965833 times.
✓ Branch 1 taken 5965820 times.
✓ Branch 2 taken 5965117 times.
✓ Branch 3 taken 716 times.
 11931653 if (!flag && field_length) {
9934
2/2
✓ Branch 0 taken 1363031 times.
✓ Branch 1 taken 4602086 times.
 5965117 if (blob_flag)
9935 1363031 return field_length / cs->mbminlen;
9936 else
9937 4602086 return field_length / cs->mbmaxlen;
9938
4/4
✓ Branch 0 taken 5965820 times.
✓ Branch 1 taken 716 times.
✓ Branch 2 taken 5965104 times.
✓ Branch 3 taken 716 times.
 5966536 } else if (flag && field_length) {
9939 5965104 return field_length;
9940 }
9941
9942 1432 return 0;
9943 19871160 }
9944
9945 2094187 longlong Item_func_internal_get_view_warning_or_error::val_int() {
9946
1/2
✓ Branch 0 taken 2094187 times.
✗ Branch 1 not taken.
 2094187 DBUG_TRACE;
9947
9948 2094187 String schema_name;
9949 2094187 String table_name;
9950 2094187 String table_type;
9951
1/2
✓ Branch 0 taken 2094187 times.
✗ Branch 1 not taken.
 2094187 String *schema_name_ptr = args[0]->val_str(&schema_name);
9952
1/2
✓ Branch 0 taken 2094187 times.
✗ Branch 1 not taken.
 2094187 String *table_name_ptr = args[1]->val_str(&table_name);
9953
1/2
✓ Branch 0 taken 2094187 times.
✗ Branch 1 not taken.
 2094187 String *table_type_ptr = args[2]->val_str(&table_type);
9954
9955
4/6
✓ Branch 0 taken 2094184 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2094184 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2094184 times.
 2094187 if (table_type_ptr == nullptr || schema_name_ptr == nullptr ||
9956 table_name_ptr == nullptr) {
9957 3 return 0;
9958 }
9959
9960 2094184 String options;
9961
1/2
✓ Branch 0 taken 2094184 times.
✗ Branch 1 not taken.
 2094184 String *options_ptr = args[3]->val_str(&options);
9962
6/8
✓ Branch 0 taken 2094184 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14629 times.
✓ Branch 3 taken 2079555 times.
✓ Branch 4 taken 14629 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 14629 times.
✓ Branch 7 taken 2079555 times.
 2094184 if (strcmp(table_type_ptr->c_ptr_safe(), "VIEW") == 0 &&
9963 options_ptr != nullptr) {
9964 14629 bool is_view_valid = true;
9965 std::unique_ptr<dd::Properties> view_options(
9966
3/6
✓ Branch 0 taken 14629 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14629 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14629 times.
✗ Branch 5 not taken.
 14629 dd::Properties::parse_properties(options_ptr->c_ptr_safe()));
9967
9968 // Warn if the property string is corrupt.
9969
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14629 times.
 14629 if (!view_options.get()) {
9970 ✗ LogErr(WARNING_LEVEL, ER_WARN_PROPERTY_STRING_PARSE_FAILED,
9971 options_ptr->c_ptr_safe());
9972 ✗ assert(false);
9973 return 0;
9974 }
9975
9976 // Return 0 if get_bool() or push_view_warning_or_error() fails
9977
3/6
✓ Branch 0 taken 14629 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14629 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 14629 times.
 14629 if (view_options->get("view_valid", &is_view_valid)) return 0;
9978
9979
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 14613 times.
 14629 if (is_view_valid == false) {
9980
2/4
✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
✗ Branch 3 not taken.
 16 push_view_warning_or_error(current_thd, schema_name_ptr->c_ptr_safe(),
9981
2/4
✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
✗ Branch 3 not taken.
 16 table_name_ptr->c_ptr_safe());
9982 16 return 0;
9983 }
9984
2/2
✓ Branch 0 taken 14613 times.
✓ Branch 1 taken 16 times.
 14629 }
9985
9986 2094168 return 1;
9987 2094187 }
9988
9989 /**
9990 @brief
9991 INFORMATION_SCHEMA picks metadata from DD using system views.
9992 INFORMATION_SCHEMA.STATISTICS.SUB_PART represents index sub part length.
9993 This internal function is used to get index sub part length.
9994
9995 Syntax:
9996 int GET_DD_INDEX_SUB_PART_LENGTH(
9997 index_column_usage_length,
9998 column_type,
9999 column_length,
10000 column_collation_id,
10001 index_type);
10002
10003 @returns Index sub part length.
10004 */
10005 4479 longlong Item_func_get_dd_index_sub_part_length::val_int() {
10006
1/2
✓ Branch 0 taken 4479 times.
✗ Branch 1 not taken.
 4479 DBUG_TRACE;
10007 4479 null_value = true;
10008
10009 // Read arguments
10010
1/2
✓ Branch 0 taken 4479 times.
✗ Branch 1 not taken.
 4479 uint key_part_length = args[0]->val_int();
10011 dd::enum_column_types col_type =
10012
1/2
✓ Branch 0 taken 4479 times.
✗ Branch 1 not taken.
 4479 static_cast<dd::enum_column_types>(args[1]->val_int());
10013
1/2
✓ Branch 0 taken 4479 times.
✗ Branch 1 not taken.
 4479 uint column_length = args[2]->val_int();
10014
1/2
✓ Branch 0 taken 4479 times.
✗ Branch 1 not taken.
 4479 uint csid = args[3]->val_int();
10015 dd::Index::enum_index_type idx_type =
10016
1/2
✓ Branch 0 taken 4479 times.
✗ Branch 1 not taken.
 4479 static_cast<dd::Index::enum_index_type>(args[4]->val_int());
10017
4/6
✓ Branch 0 taken 4466 times.
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 4466 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4466 times.
✗ Branch 5 not taken.
 4479 if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
10018
2/4
✓ Branch 0 taken 4466 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4466 times.
 4466 args[3]->null_value || args[4]->null_value)
10019 13 return 0;
10020
10021 // Read server col_type and check if we have key part.
10022
1/2
✓ Branch 0 taken 4466 times.
✗ Branch 1 not taken.
 4466 enum_field_types field_type = dd_get_old_field_type(col_type);
10023
3/4
✓ Branch 0 taken 4466 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2383 times.
✓ Branch 3 taken 2083 times.
 4466 if (!Field::type_can_have_key_part(field_type)) return 0;
10024
10025 // Calculate the key length for the column. Note that we pass inn dummy values
10026 // for "decimals", "is_unsigned" and "elements" since none of those arguments
10027 // will affect the key length for any of the data types that can have a prefix
10028 // index (see Field::type_can_have_key_part above).
10029 uint32 column_key_length =
10030
1/2
✓ Branch 0 taken 2083 times.
✗ Branch 1 not taken.
 2083 calc_key_length(field_type, column_length, 0, false, 0);
10031
10032 // Read column charset id from args[3]
10033 2083 const CHARSET_INFO *column_charset = &my_charset_latin1;
10034
1/2
✓ Branch 0 taken 2083 times.
✗ Branch 1 not taken.
 2083 if (csid) {
10035
1/2
✓ Branch 0 taken 2083 times.
✗ Branch 1 not taken.
 2083 column_charset = get_charset(csid, MYF(0));
10036
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2083 times.
 2083 assert(column_charset);
10037 }
10038
10039
4/4
✓ Branch 0 taken 2054 times.
✓ Branch 1 taken 29 times.
✓ Branch 2 taken 223 times.
✓ Branch 3 taken 1831 times.
 2083 if ((idx_type != dd::Index::IT_FULLTEXT) &&
10040 (key_part_length != column_key_length)) {
10041 223 longlong sub_part_length = key_part_length / column_charset->mbmaxlen;
10042 223 null_value = false;
10043 223 return sub_part_length;
10044 }
10045
10046 1860 return 0;
10047 4479 }
10048
10049 /**
10050 @brief
10051 Internal function used by INFORMATION_SCHEMA implementation to check
10052 if a role is a mandatory role.
10053
10054 Syntax:
10055 int INTERNAL_IS_MANDATORY_ROLE(role_user, role_host);
10056
10057 @returns,
10058 1 - If the role is mandatory.
10059 0 - If not.
10060 */
10061
10062 158 longlong Item_func_internal_is_mandatory_role::val_int() {
10063
1/2
✓ Branch 0 taken 158 times.
✗ Branch 1 not taken.
 158 DBUG_TRACE;
10064
10065 // Read schema_name
10066 158 String role_name;
10067
1/2
✓ Branch 0 taken 158 times.
✗ Branch 1 not taken.
 158 String *role_name_ptr = args[0]->val_str(&role_name);
10068 158 String role_host;
10069
1/2
✓ Branch 0 taken 158 times.
✗ Branch 1 not taken.
 158 String *role_host_ptr = args[1]->val_str(&role_host);
10070
3/4
✓ Branch 0 taken 155 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 155 times.
 158 if (role_name_ptr == nullptr || role_host_ptr == nullptr) {
10071 3 null_value = true;
10072 3 return 0;
10073 }
10074
10075 // Create Auth_id for ID being searched.
10076 LEX_CSTRING lex_user;
10077
1/2
✓ Branch 0 taken 155 times.
✗ Branch 1 not taken.
 155 lex_user.str = role_name_ptr->c_ptr_safe();
10078 155 lex_user.length = role_name_ptr->length();
10079
10080 LEX_CSTRING lex_host;
10081
1/2
✓ Branch 0 taken 155 times.
✗ Branch 1 not taken.
 155 lex_host.str = role_host_ptr->c_ptr_safe();
10082 155 lex_host.length = role_host_ptr->length();
10083
10084 155 bool is_mandatory{false};
10085
3/4
✓ Branch 0 taken 155 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 154 times.
 155 if (is_mandatory_role(lex_user, lex_host, &is_mandatory)) {
10086 4 push_warning_printf(
10087
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 current_thd, Sql_condition::SL_WARNING,
10088 ER_FAILED_TO_DETERMINE_IF_ROLE_IS_MANDATORY,
10089
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 ER_THD(current_thd, ER_FAILED_TO_DETERMINE_IF_ROLE_IS_MANDATORY),
10090 lex_user.str, lex_host.str);
10091 }
10092
10093 155 return is_mandatory;
10094 158 }
10095
10096 /**
10097 @brief
10098 Internal function used by INFORMATION_SCHEMA implementation to check
10099 if a role enabled.
10100
10101 Syntax:
10102 int INTERNAL_IS_ENABLED_ROLE(role_user, role_host);
10103
10104 @returns,
10105 1 - If the role is enabled.
10106 0 - If not.
10107 */
10108
10109 438 longlong Item_func_internal_is_enabled_role::val_int() {
10110
1/2
✓ Branch 0 taken 438 times.
✗ Branch 1 not taken.
 438 DBUG_TRACE;
10111
1/2
✓ Branch 0 taken 438 times.
✗ Branch 1 not taken.
 438 THD *thd = current_thd;
10112
10113 // Read schema_name
10114 438 String role_name;
10115
1/2
✓ Branch 0 taken 438 times.
✗ Branch 1 not taken.
 438 String *role_name_ptr = args[0]->val_str(&role_name);
10116 438 String role_host;
10117
1/2
✓ Branch 0 taken 438 times.
✗ Branch 1 not taken.
 438 String *role_host_ptr = args[1]->val_str(&role_host);
10118
3/4
✓ Branch 0 taken 435 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 435 times.
 438 if (role_name_ptr == nullptr || role_host_ptr == nullptr) {
10119 3 null_value = true;
10120 3 return 0;
10121 }
10122
10123
3/4
✓ Branch 0 taken 435 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 199 times.
✓ Branch 3 taken 236 times.
 435 if (thd->m_main_security_ctx.get_active_roles()->size() == 0) return 0;
10124
10125 // Create Auth_id for ID being searched.
10126 LEX_CSTRING lex_user;
10127
1/2
✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
 236 lex_user.str = role_name_ptr->c_ptr_safe();
10128 236 lex_user.length = role_name_ptr->length();
10129
10130 LEX_CSTRING lex_host;
10131
1/2
✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
 236 lex_host.str = role_host_ptr->c_ptr_safe();
10132 236 lex_host.length = role_host_ptr->length();
10133
10134 // Match the ID and return true if found.
10135
3/4
✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 241 times.
✓ Branch 3 taken 185 times.
 426 for (auto &rid : *thd->m_main_security_ctx.get_active_roles()) {
10136
4/6
✓ Branch 0 taken 241 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 241 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 51 times.
✓ Branch 5 taken 190 times.
 241 if (rid == std::make_pair(lex_user, lex_host)) return 1;
10137 }
10138
10139 185 return 0;
10140 438 }
10141